anchor.diff:  		Bit#(mbits))) rState_S1 <- mkReg(unpack(0));
      Reg#(Bool) rValid_S1 <- mkReg(False);
   
  -   // check operands, compute exponent for multiply
  -   rule s1_stage;
  -      match { .mopA, .opB, .opC } = wOperand_S0;
  -      let valid = wValid_S0;
  -
  -      CommonState#(e,m) s = CommonState {
  -	 res: tagged Invalid,
  -	 exc: defaultValue,
  -	 rmode: rmode
  -	 };
  -
  -      Bool acc = False;
  -      FloatingPoint#(e,m) opA = 0;
  -
  -      if (mopA matches tagged Valid .opA_) begin
  -	 opA = opA_;
  -	 acc = True;
  -      end
  -
  -      Int#(ebits) expB = isSubNormal(opB) ? fromInteger(minexp(opB)) : signExtend(unpack(unbias(opB)));
  -      Int#(ebits) expC = isSubNormal(opC) ? fromInteger(minexp(opC)) : signExtend(unpack(unbias(opC)));
  -
  -      Bit#(mbits) sfdB = { getHiddenBit(opB), opB.sfd };
  -      Bit#(mbits) sfdC = { getHiddenBit(opC), opC.sfd };
  -
  -      Bool sgnBC = opB.sign != opC.sign;
  -      Bool infBC = isInfinity(opB) || isInfinity(opC);
  -      Bool zeroBC = isZero(opB) || isZero(opC);
  -      Int#(ebits) expBC = expB + expC;
  -
  -      if (isSNaN(opA)) begin
  -	 s.res = tagged Valid nanQuiet(opA);
  -	 s.exc.invalid_op = True;
  -      end
  -      else if (isSNaN(opB)) begin
  -	 s.res = tagged Valid nanQuiet(opB);
  -	 s.exc.invalid_op = True;
  -      end
  -      else if (isSNaN(opC)) begin
  -	 s.res = tagged Valid nanQuiet(opC);
  -	 s.exc.invalid_op = True;
  -      end
  -      else if (isQNaN(opA)) begin
  -	 s.res = tagged Valid opA;
  -      end
  -      else if (isQNaN(opB)) begin
  -	 s.res = tagged Valid opB;
  -      end
  -      else if (isQNaN(opC)) begin
  -	 s.res = tagged Valid opC;
  -      end
  -      else if ((isInfinity(opB) && isZero(opC)) || (isZero(opB) && isInfinity(opC)) || (isInfinity(opA) && infBC && (opA.sign != sgnBC))) begin
  -	 // product of zero and infinity or addition of opposite sign infinity
  -	 s.res = tagged Valid qnan();
  -	 s.exc.invalid_op = True;
  -      end
  -      else if (isInfinity(opA)) begin
  -	 s.res = tagged Valid opA;
  -      end
  -      else if (infBC) begin
  -	 s.res = tagged Valid infinity(sgnBC);
  -      end
  -      else if (isZero(opA) && zeroBC && (opA.sign == sgnBC)) begin
  -	 s.res = tagged Valid opA;
  -      end
  -
  -      
  -      rState_S1 <= tuple7(s,
  -			  acc,
  -			  opA,
  -			  sgnBC,
  -			  expBC,
  -			  sfdB,
  -			  sfdC);
  -      rValid_S1 <= valid;
  -   endrule
  +   FIFOF#(Tuple2#(FloatingPoint#(e,m),Exception)) fResult_S9 <- mkLFIFOF();
   
      Reg#(Tuple5#(CommonState#(e,m),
   		Bool,
  
positive.code: 		 Bit#(2))) rState_S4 <- mkReg(unpack(0));
     Reg#(Bool) rValid_S4 <- mkReg(False);
  
     // normalize multiplication result
     rule s4_stage;
        match { .s, .acc, .opA, .sgnBC, .expBC } <- toGet(rState_S3).get;
        let valid = rValid_S3;
  
        let sfdBC = pack(rProd_S3);
        
        FloatingPoint#(e,m) bc = defaultValue;
        Bit#(2) guardBC = ?;
  
        if (s.res matches tagged Invalid) begin
  	 if (expBC > fromInteger(maxexp(bc))) begin
  	    bc.sign = sgnBC;
  	    bc.exp = maxBound - 1;
  	    bc.sfd = maxBound;
  	    guardBC = '1;
  
  	    s.exc.overflow = True;
  	    s.exc.inexact = True;
  	 end
  	 else if (expBC < (fromInteger(minexp_subnormal(bc))-2)) begin
  	    bc.sign = sgnBC;
  	    bc.exp = 0;
  	    bc.sfd = 0;
  	    guardBC = 0;
  
  	    if (|sfdBC == 1) begin
  	       guardBC = 1;
  	       s.exc.underflow = True;
  	       s.exc.inexact = True;
  	    end
  	 end
  	 else begin
  	    let shift = fromInteger(minexp(bc)) - expBC;
  	    if (shift > 0) begin
  	       // subnormal
  	       Bit#(1) sfdlsb = |(sfdBC << (fromInteger(valueOf(mmbits)) - shift));
  
  	       sfdBC = sfdBC >> shift;
  	       sfdBC[0] = sfdBC[0] | sfdlsb;
  
  	       bc.exp = 0;
  	    end
  	    else begin
  	       bc.exp = cExtend(expBC + fromInteger(bias(bc)));
  	    end
  
  	    bc.sign = sgnBC;
  	    let y = normalize(bc, sfdBC);
  	    bc = tpl_1(y);
  	    guardBC = tpl_2(y);
  	    s.exc = s.exc | tpl_3(y);
  	 end
        end
  
        rState_S4 <= tuple5(s,
  			  acc,
  			  opA,
  			  bc,
  			  guardBC);
        rValid_S4 <= valid;
     endrule
  
     Reg#(Tuple8#(CommonState#(e,m),
  		Bool,
  		Bool,
  
negative.code: 		Bit#(m5bits))) rState_S5 <- mkReg(unpack(0));
     Reg#(Bool) rValid_S5 <- mkReg(False);
  
     Reg#(Tuple7#(CommonState#(e,m),
  		Bool,
  		Bool,
  