package FloatingPoint;





// ************************************************************************** //
//                                                                            //
//    eses                   eses                                             //
//   eses                     eses                                            //
//  eses    eseses  esesese    eses   Embedded Systems Group                  //
//  ese    ese  ese ese         ese                                           //
//  ese    eseseses eseseses    ese   Department of Computer Science          //
//  eses   eses          ese   eses                                           //
//   eses   eseses  eseseses  eses    University of Kaiserslautern            //
//    eses                   eses                                             //
//                                                                            //
// ************************************************************************** //
// This module implements addition of floating point numbers that conform     //
// with IEEE 754-2008 standard.                                               //
// The algorithm below deals with the full IEEE standard including denormal   //
// and normal numbers, infinity and NaN values.                               //
// ************************************************************************** //

// parameters of the floating-point format
macro MantWidth = 4;
macro ExpWidth  = 3;
macro ExpMax    = exp(2,ExpWidth)-1;
macro ExpBias   = ExpMax / 2;
macro ExpMin    = +1 - ExpBias;
macro Width     = 1+ExpWidth+MantWidth;

macro MantMinNorm = exp(2,MantWidth-1);  // smallest normalized mantissa
macro MantMax     = exp(2,MantWidth)-1;  // largest mantissa value

// macros for extracting parts of the floating point number
macro Sign(x) = x{-1};
macro Exp(x)  = x{-2:MantWidth};
macro Mant(x) = x{MantWidth-1:0};
macro RmHBit(x) = Mant(x);            // remove hidden bit

// macros for interpretation of the floating point numbers
macro ValSign(s)    = (s?-1.0:1.0);
macro ValNMant(m)   = bv2nat(true@m)  * exp(2.0,-1*MantWidth);
macro ValDMant(m)   = bv2nat(false@m) * exp(2.0,-1*MantWidth);
macro ValMant(e,m)  = (e=={false::ExpWidth} ? ValDMant(m) : ValNMant(m));
macro ValNExp(e)    = +bv2nat(e)-ExpBias;
macro ValDExp(e)    = +1-ExpBias;
macro ValExp(e)     = (e=={false::ExpWidth} ? ValDExp(e) : ValNExp(e));
macro Float2Real(x) = ValSign(Sign(x)) * ValMant(Exp(x),Mant(x)) * exp(2.0,ValExp(Exp(x)));

// special values
macro posZero = false@{false::ExpWidth}@{false::MantWidth};
macro negZero =  true@{false::ExpWidth}@{false::MantWidth};
macro posInf  = false@{ true::ExpWidth}@{false::MantWidth};
macro negInf  =  true@{ true::ExpWidth}@{false::MantWidth};
macro posNaN  = false@{ true::ExpWidth}@{ true::MantWidth};
macro negNaN  =  true@{ true::ExpWidth}@{ true::MantWidth};


// Definition of some operations: declaration as macro
macro isZero(x)      = ( ( Exp(x) == {false::ExpWidth} ) & ( Mant(x) == {false::MantWidth} ) );
macro isNormal(x)    = ( 1 <= bv2nat(Exp(x)) ) & ( bv2nat(Exp(x)) <= (exp(2,ExpWidth)-2) );
macro isSubnormal(x) = ( Exp(x) == {false::ExpWidth} ) & ( Mant(x) != {false::MantWidth} );
macro isFinite(x)    = ( isZero(x) | isSubnormal(x) | isNormal(x) );
macro isInfinite(x)  = ( Exp(x) == {true::ExpWidth} ) & ( Mant(x) == {false::MantWidth} );
macro isNaN(x)       = ( Exp(x) == {true::ExpWidth} ) & ( Mant(x) != {false::MantWidth} );
macro isSignMinus(x) = ( Sign(x) != false );

// Macros that return a float
macro fAbs(x)         = (false@Exp(x)@Mant(x));
macro fCopySign(x,y)  = (Sign(y)@Exp(x)@Mant(x));
macro fNegate(x)      = ((Sign(x) ? false : true)@Exp(x)@Mant(x));


// here comes the main module: it first deals with special cases like NaN, Zero and Infinities
// according to the IEEE standard and then (in the largest part of case construct) handles
// normal and denormal numbers

module FloatAdd(bv{Width} ?x,?y,!z,event !rdy) {
    // Temporarily used variables: basically
    //     xA = (abs(x) >= (abs(y)) ? x : y;
    //     yA = (abs(x) >= (abs(y)) ? y : x;
    // They are used for the actual operation to
    // reduce the special handling of shift operations
    // and sign handling.
    // The addition is based on 2 complement integer
    // arithmetic, therefore, we need an extra bit.
    // Another bit is required to store the hidden bit.
    bv{MantWidth+2} m0, m1;
    bv{MantWidth+2} mr; // mantissa of the result: (basically) mr=m0+m1
    bool sr;  // sign of the result
    int er; // exponent of the result
    nat ExpDiff;
    bool guard, round, sticky;
    bool selectX; // true if fAbs(x) > fAbs(y) holds

    case // define special cases according to IEEE standard
        ( isInfinite(x) & isInfinite(y) & Sign(x) != Sign(y) ) do {
            z = posNaN;
            emit(rdy);
            }
        (isNaN(x)) do {
            z = x;
            emit(rdy);
            }
        (isNaN(y)) do {
            z = y;
            emit(rdy);
            }
    default {
        let(nx = isNormal(x) )
        let(ny = isNormal(y) )
        let(mx = nx@Mant(x) )
        let(my = ny@Mant(y) ) {

        // Step 1: We reduce cases by bringing the inputs
        // into a specific ordering: abs(add0) >= abs(add1)
        // with add0 and add1 are the inputs of the addition.
        selectX = ( ( bv2nat(Exp(x)) > bv2nat(Exp(y)) ) |
                    ( bv2nat(Exp(x))==bv2nat(Exp(y)) & bv2nat(Mant(x)) >= bv2nat(Mant(y)) ) );
        if( selectX ) {
            m0 = false@mx;
            m1 = false@my;
            ExpDiff = +ValExp(Exp(x)) - ValExp(Exp(y));
        } else { // selectY => fAbs(y) > fAbs(x)
            m0 = false@my;
            m1 = false@mx;
            ExpDiff = +ValExp(Exp(y)) - ValExp(Exp(x));
        }
        
        } // end let, let, let, let

        // Step 2: handling of signs. If the signs of the
        // inputs are different, we have to compute m0-m1.
        // This is implemented by computing m0 + (-m1), i.e
        // we negate m1 if the signs of the inputs are different.
        if( Sign(x) != Sign(y) ) {
            next(m1) = int2bv( -bv2int(m1), MantWidth + 2);
            pause;
        }
        
        // Step 3: right-shift m1 by ExpDiff bits. Compute
        // guard bit, round bit and sticky bit while shifting.
        guard = false;
        round = false;
        sticky = false;
        while( ExpDiff > 0 ) {
            next(sticky) = sticky | round;
            next(round) = guard;
            next(guard) = m1{0};
            next(m1) = m1{-1}@m1{-1:1};
            next(ExpDiff) = ExpDiff - 1;
            pause;
        }

        // Step 4: Add m0 and m1
        mr = int2bv(bv2int(m0) + bv2int(m1), MantWidth+2);

        // Step 5:  Normalize (mr)
        // Step 5a: determine exponent. The exponent might need to be
        //          corrected and cause an overflow or 
        if( selectX ) {
            er = ValExp(Exp(x));
        } else {
            er = ValExp(Exp(y));
        }

        // Step 5b: Shift mr until we have the form 01.xxxxx
        // mr:=[mr{-1}, mr{-2}, mr{-3}, ..., mr{1}, mr{0}];
        // mr{-1}: is the 2k-sign bit, which is expected to be '0',
        //         since we ensured that fAbs(m0) >= fAbs(m1)
        // mr{-2}: is expected to be '1' after normalization

        // An overflow could cause mr{-1} to be '1'. This occurs only
        // for 'real' additions (both inputs have the same sign). We
        // still do not need an additional bit, because the overflow
        // can be identified by checking the sign bit, which would be
        // '1' in case of an overflow. In that case, we have to right
        // shift the mantissa by one bit and correct the exponent
        // accordingly.
        if( mr{-1} ) {
            next(mr) = false@mr{-1:1};
            next(er) = er + 1; // check for overflow is done below

            next(sticky) = sticky | round;
            next(round) = guard;
            next(guard) = mr{0}; // first bit of addition
            pause;
        } else {
            while( !mr{-2} & er > ExpMin ) {
                next(mr) = mr{-2:0}@guard;
                next(er) = er - 1;
                // NOTE: actual sticky bit used for rounding below is
                //       (round|sticky)
                next(sticky) = sticky;            // not exactly reproducable
                next(round) = false;              // not exactly reproducable
                next(guard) = round;
                pause;
            }
            // NOTE: if mr{-2}==0 at that point, then we have a denormalized number
        }

        // Step 5c: Round mr
        // NOTE: We ensured that m0 >= m1 --> mr is positive!
        if( ( guard & (round|sticky) ) |
            ( guard & !(round|sticky) & mr{0} ) ) {
            next(mr) = int2bv(bv2int(mr) + 1, MantWidth+2);
            pause;

            // Step 5c ii: check overflow of mr after rounding
            if( mr{-1} ) {
                next(mr) = false@mr{-1:1};
                next(er) = er + 1; // check for overflow is done below
                pause;
            }
        }

        // Step 6: compute the sign of the result. We know that
        //         the selected input for m0 has a larger absolute
        //         value, i.e. fAbs(m0) > fAbs(m1). The sign of
        //         the result must be the same as the sign of the
        //         first operand.
        if( selectX ) {
            sr = ( (mr{-2:-2-MantWidth}=={false::(MantWidth+1)}) ? false : Sign(x) );
        } else {
            sr = ( (mr{-2:-2-MantWidth}=={false::(MantWidth+1)}) ? false : Sign(y) );
        }

        // Final Step: build result from partial computations.
        if( er > ExpMax ) { // overflow?
            z = ( sr ? negInf : posInf );
        } else {
            if( !mr{-2} ) { // denormalized number (see above)
                z = sr@{false::ExpWidth}@mr{-3:-2-MantWidth};
            } else  {
                z = sr@(nat2bv(abs(er + ExpBias), ExpWidth))@mr{-3:-2-MantWidth};
            }
        }

        emit(rdy);
    }
}
// ---------------------------------------------
// Cover first case in code
drivenby { // 0
    x = posInf;
    y = negInf;
    immediate abort { await(false); } when (rdy);
    assert(z == posNaN);
}
drivenby { // 1
    x = negInf;
    y = posInf;
    immediate abort { await(false); } when (rdy);
    assert(z == posNaN);
}
// ---------------------------------------------
// Cover second case in code
drivenby { // 2
    x = posNaN;
    y = posInf;
    immediate abort { await(false); } when (rdy);
    assert(z == posNaN);
}
drivenby { // 3
    x = negNaN;
    y = negZero;
    immediate abort { await(false); } when (rdy);
    assert(z == negNaN);
}
drivenby { // 4
    x = posNaN;
    y = false@0b010@0b1100;
    immediate abort { await(false); } when (rdy);
    assert(z == posNaN);
}
drivenby { // 5
    x = negNaN;
    y = true@0b110@0b0001;
    immediate abort { await(false); } when (rdy);
    assert(z == negNaN);
}
// ---------------------------------------------
// Cover third case in code
drivenby { // 6
    x = posInf;
    y = posNaN;
    immediate abort { await(false); } when (rdy);
    assert(z == posNaN);
}
drivenby { // 7
    x = negZero;
    y = negNaN;
    immediate abort { await(false); } when (rdy);
    assert(z == negNaN);
}
drivenby { // 8
    x = false@0b011@0b1010;
    y = posNaN;
    immediate abort { await(false); } when (rdy);
    assert(z == posNaN);
}
drivenby { // 9
    x = true@0b001@0b1011;
    y = negNaN;
    immediate abort { await(false); } when (rdy);
    assert(z == negNaN);
}
// ---------------------------------------------
// Cover default case in code
drivenby { // 10
    x = posZero;
    y = posZero;
    immediate abort { await(false); } when (rdy);
    assert(z == posZero);
}
drivenby { // 11
    x = posZero;
    y = negZero;
    immediate abort { await(false); } when (rdy);
    assert(z == posZero);
}
drivenby { // 12
    x = negZero;
    y = posZero;
    immediate abort { await(false); } when (rdy);
    assert(z == posZero);
}
drivenby { // 13
    x = negZero;
    y = negZero;
    immediate abort { await(false); } when (rdy);
    assert(z == posZero);
}
drivenby { // 14
    x = posInf;
    y = posInf;
    immediate abort { await(false); } when (rdy);
    assert(z == posInf);
}
drivenby { // 15
    x = negInf;
    y = negInf;
    immediate abort { await(false); } when (rdy);
    assert(z == posInf);
}
// --------------------
// normalized numbers (hand-written)
drivenby { // 16
    x = false@0b011@0b0000;
    y = false@0b011@0b0000;
    immediate abort { await(false); } when (rdy);
    assert(z == false@0b100@0b0000);
}
drivenby { // 17
    x = false@0b011@0b0000;
    y = true@0b011@0b0000;
    immediate abort { await(false); } when (rdy);
    assert(z == posZero);
}
drivenby { // 18
    x = true@0b011@0b0000;
    y = false@0b011@0b0000;
    immediate abort { await(false); } when (rdy);
    assert(z == posZero);
}
drivenby { // 19
    x = true@0b011@0b0000;
    y = true@0b011@0b0000;
    immediate abort { await(false); } when (rdy);
    assert(z == true@0b100@0b0000);
}

drivenby { // 20
    x = false@0b001@0b0000;
    y = false@0b001@0b0000;
    immediate abort { await(false); } when (rdy);
    assert(z == false@0b010@0b0000);
}
drivenby { // 21
    x = false@0b110@0b0000;
    y = false@0b110@0b0000;
    immediate abort { await(false); } when (rdy);
    assert(z == posInf);
}

drivenby { // 22
    x = false@0b011@0b1000;
    y = false@0b010@0b0000;
    immediate abort { await(false); } when (rdy);
    assert(z == false@0b100@0b0000);
}
drivenby { // 23
    x = false@0b011@0b0000;
    y = false@0b010@0b0000;
    immediate abort { await(false); } when (rdy);
    assert(z == false@0b011@0b1000);
}

// --------------------
// denormalized numbers
drivenby { // 24
    x = false@0b000@0b0001;
    y = false@0b000@0b0001;
    immediate abort { await(false); } when (rdy);
    assert(z == false@0b000@0b0010);
}
drivenby { // 25
    x = false@0b000@0b0001;
    y = false@0b000@0b0010;
    immediate abort { await(false); } when (rdy);
    assert(z == false@0b000@0b0011);
}
drivenby { // 26
    x = false@0b000@0b1000;
    y = false@0b000@0b1000;
    immediate abort { await(false); } when (rdy);
    assert(z == false@0b001@0b0000);
}
// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------








// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
// auto-generated test cases
drivenby { // case 27
  x = (true@0b100@0b1001);
  y = (true@0b101@0b1111);
  // x + y
  //   -3.1250000) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // +(-7.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // ----------------------------------------------
  //   -10.8750000) = (-1)^(1) * 2^(6 - 3) * 1.0110
  // (-1)^(1) * 2^(6 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0110));
}
drivenby { // case 28
  x = (false@0b000@0b0100);
  y = (true@0b010@0b1011);
  // x + y
  //   +0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // +(-0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   -0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // (-1)^(1) * 2^(2 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1001));
}
drivenby { // case 29
  x = (false@0b001@0b0011);
  y = (false@0b000@0b0001);
  // x + y
  //   +0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // +(+0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   +0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // (-1)^(0) * 2^(1 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0100));
}
drivenby { // case 30
  x = (false@0b100@0b1011);
  y = (false@0b011@0b1101);
  // x + y
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // +(+1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // ----------------------------------------------
  //   +5.1875000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // (-1)^(0) * 2^(5 - 3) * 10100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0101));
}
drivenby { // case 31
  x = (false@0b010@0b1110);
  y = (true@0b001@0b1111);
  // x + y
  //   +0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // +(-0.4843750) = (-1)^(1) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   +0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // (-1)^(0) * 2^(1 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1101));
}
drivenby { // case 32
  x = (true@0b000@0b0011);
  y = (false@0b101@0b0111);
  // x + y
  //   -0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // +(+5.7500000) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // ----------------------------------------------
  //   +5.7031250) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // (-1)^(0) * 2^(5 - 3) * 10110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0111));
}
drivenby { // case 33
  x = (true@0b100@0b0011);
  y = (false@0b011@0b1101);
  // x + y
  //   -2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // +(+1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // ----------------------------------------------
  //   -0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // (-1)^(1) * 2^(2 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0010));
}
drivenby { // case 34
  x = (true@0b101@0b1000);
  y = (true@0b010@0b0100);
  // x + y
  //   -6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // +(-0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // ----------------------------------------------
  //   -6.6250000) = (-1)^(1) * 2^(5 - 3) * 1.1010
  // (-1)^(1) * 2^(5 - 3) * 11010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1010));
}
drivenby { // case 35
  x = (true@0b000@0b0110);
  y = (false@0b001@0b0100);
  // x + y
  //   -0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   +0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // (-1)^(0) * 2^(0 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1110));
}
drivenby { // case 36
  x = (false@0b011@0b1110);
  y = (false@0b100@0b0001);
  // x + y
  //   +1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // +(+2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // ----------------------------------------------
  //   +4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // (-1)^(0) * 2^(5 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0000));
}
drivenby { // case 37
  x = (true@0b011@0b1100);
  y = (true@0b010@0b1001);
  // x + y
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // +(-0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   -2.5312500) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 38
  x = (false@0b011@0b0001);
  y = (true@0b000@0b0011);
  // x + y
  //   +1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // +(-0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // ----------------------------------------------
  //   +1.0156250) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 39
  x = (false@0b011@0b1110);
  y = (true@0b010@0b1100);
  // x + y
  //   +1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // +(-0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   +1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 40
  x = (true@0b010@0b1111);
  y = (false@0b000@0b0101);
  // x + y
  //   -0.9687500) = (-1)^(1) * 2^(2 - 3) * 1.1111
  // +(+0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   -0.8906250) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // (-1)^(1) * 2^(2 - 3) * 11100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1100));
}
drivenby { // case 41
  x = (false@0b000@0b1101);
  y = (true@0b010@0b1111);
  // x + y
  //   +0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // +(-0.9687500) = (-1)^(1) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   -0.7656250) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // (-1)^(1) * 2^(2 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1000));
}
drivenby { // case 42
  x = (false@0b000@0b0110);
  y = (false@0b001@0b1100);
  // x + y
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // +(+0.4375000) = (-1)^(0) * 2^(1 - 3) * 1.1100
  // ----------------------------------------------
  //   +0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // (-1)^(0) * 2^(2 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0001));
}
drivenby { // case 43
  x = (false@0b000@0b1111);
  y = (true@0b011@0b1010);
  // x + y
  //   +0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // +(-1.6250000) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // ----------------------------------------------
  //   -1.3906250) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // (-1)^(1) * 2^(3 - 3) * 10110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0110));
}
drivenby { // case 44
  x = (false@0b100@0b1011);
  y = (true@0b101@0b0110);
  // x + y
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // +(-5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   -2.1250000) = (-1)^(1) * 2^(4 - 3) * 1.0001
  // (-1)^(1) * 2^(4 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0001));
}
drivenby { // case 45
  x = (true@0b000@0b1110);
  y = (false@0b001@0b1000);
  // x + y
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // +(+0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   +0.1562500) = (-1)^(0) * 2^(1 - 3) * 0.1010
  // (-1)^(0) * 2^(0 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1010));
}
drivenby { // case 46
  x = (false@0b001@0b1001);
  y = (true@0b100@0b1011);
  // x + y
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // +(-3.3750000) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   -2.9843750) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // (-1)^(1) * 2^(4 - 3) * 10111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1000));
}
drivenby { // case 47
  x = (false@0b011@0b1111);
  y = (true@0b011@0b1011);
  // x + y
  //   +1.9375000) = (-1)^(0) * 2^(3 - 3) * 1.1111
  // +(-1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // (-1)^(0) * 2^(1 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0000));
}
drivenby { // case 48
  x = (true@0b101@0b0101);
  y = (true@0b011@0b0000);
  // x + y
  //   -5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // +(-1.0000000) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // ----------------------------------------------
  //   -6.2500000) = (-1)^(1) * 2^(5 - 3) * 1.1001
  // (-1)^(1) * 2^(5 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1001));
}
drivenby { // case 49
  x = (true@0b011@0b1010);
  y = (true@0b100@0b1011);
  // x + y
  //   -1.6250000) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // +(-3.3750000) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   -5.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // (-1)^(1) * 2^(5 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0100));
}
drivenby { // case 50
  x = (true@0b010@0b1000);
  y = (true@0b010@0b1101);
  // x + y
  //   -0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // +(-0.9062500) = (-1)^(1) * 2^(2 - 3) * 1.1101
  // ----------------------------------------------
  //   -1.6562500) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // (-1)^(1) * 2^(3 - 3) * 11010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1010));
}
drivenby { // case 51
  x = (true@0b101@0b1110);
  y = (false@0b100@0b1011);
  // x + y
  //   -7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // +(+3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   -4.1250000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(5 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 52
  x = (false@0b011@0b0100);
  y = (true@0b010@0b0101);
  // x + y
  //   +1.2500000) = (-1)^(0) * 2^(3 - 3) * 1.0100
  // +(-0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // ----------------------------------------------
  //   +0.5937500) = (-1)^(0) * 2^(2 - 3) * 1.0011
  // (-1)^(0) * 2^(2 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0011));
}
drivenby { // case 53
  x = (false@0b011@0b1001);
  y = (true@0b101@0b0000);
  // x + y
  //   +1.5625000) = (-1)^(0) * 2^(3 - 3) * 1.1001
  // +(-4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   -2.4375000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 54
  x = (false@0b010@0b0001);
  y = (false@0b001@0b1100);
  // x + y
  //   +0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // +(+0.4375000) = (-1)^(0) * 2^(1 - 3) * 1.1100
  // ----------------------------------------------
  //   +0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // (-1)^(0) * 2^(2 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1111));
}
drivenby { // case 55
  x = (false@0b100@0b1100);
  y = (false@0b101@0b0000);
  // x + y
  //   +3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // +(+4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // (-1)^(0) * 2^(5 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1110));
}
drivenby { // case 56
  x = (true@0b011@0b0011);
  y = (true@0b011@0b0000);
  // x + y
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // +(-1.0000000) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // ----------------------------------------------
  //   -2.1875000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // (-1)^(1) * 2^(4 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0010));
}
drivenby { // case 57
  x = (false@0b101@0b0101);
  y = (false@0b101@0b1111);
  // x + y
  //   +5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // +(+7.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1111
  // ----------------------------------------------
  //   +13.0000000) = (-1)^(0) * 2^(6 - 3) * 1.1010
  // (-1)^(0) * 2^(6 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b1010));
}
drivenby { // case 58
  x = (false@0b001@0b1010);
  y = (true@0b101@0b0101);
  // x + y
  //   +0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // +(-5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   -4.8437500) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // (-1)^(1) * 2^(5 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0011));
}
drivenby { // case 59
  x = (true@0b001@0b1010);
  y = (false@0b011@0b0011);
  // x + y
  //   -0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // +(+1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   +0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // (-1)^(0) * 2^(2 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1001));
}
drivenby { // case 60
  x = (false@0b011@0b1000);
  y = (false@0b001@0b0011);
  // x + y
  //   +1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // +(+0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // ----------------------------------------------
  //   +1.7968750) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // (-1)^(0) * 2^(3 - 3) * 11100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1101));
}
drivenby { // case 61
  x = (true@0b010@0b1110);
  y = (false@0b100@0b0010);
  // x + y
  //   -0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // (-1)^(0) * 2^(3 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0101));
}
drivenby { // case 62
  x = (false@0b000@0b1100);
  y = (true@0b101@0b0100);
  // x + y
  //   +0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // +(-5.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // ----------------------------------------------
  //   -4.8125000) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // (-1)^(1) * 2^(5 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0011));
}
drivenby { // case 63
  x = (false@0b011@0b1110);
  y = (true@0b010@0b1011);
  // x + y
  //   +1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // +(-0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   +1.0312500) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 64
  x = (false@0b101@0b1100);
  y = (false@0b101@0b1011);
  // x + y
  //   +7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // +(+6.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1011
  // ----------------------------------------------
  //   +13.7500000) = (-1)^(0) * 2^(6 - 3) * 1.1100
  // (-1)^(0) * 2^(6 - 3) * 11011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b1100));
}
drivenby { // case 65
  x = (false@0b100@0b0101);
  y = (false@0b000@0b1000);
  // x + y
  //   +2.6250000) = (-1)^(0) * 2^(4 - 3) * 1.0101
  // +(+0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // ----------------------------------------------
  //   +2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // (-1)^(0) * 2^(4 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0110));
}
drivenby { // case 66
  x = (true@0b011@0b1011);
  y = (false@0b010@0b0011);
  // x + y
  //   -1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // +(+0.5937500) = (-1)^(0) * 2^(2 - 3) * 1.0011
  // ----------------------------------------------
  //   -1.0937500) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // (-1)^(1) * 2^(3 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0010));
}
drivenby { // case 67
  x = (false@0b000@0b1001);
  y = (true@0b100@0b0000);
  // x + y
  //   +0.1406250) = (-1)^(0) * 2^(1 - 3) * 0.1001
  // +(-2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // ----------------------------------------------
  //   -1.8593750) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // (-1)^(1) * 2^(3 - 3) * 11101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1110));
}
drivenby { // case 68
  x = (false@0b100@0b1111);
  y = (false@0b011@0b1001);
  // x + y
  //   +3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // +(+1.5625000) = (-1)^(0) * 2^(3 - 3) * 1.1001
  // ----------------------------------------------
  //   +5.4375000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 69
  x = (true@0b000@0b0111);
  y = (true@0b000@0b1000);
  // x + y
  //   -0.1093750) = (-1)^(1) * 2^(1 - 3) * 0.0111
  // +(-0.1250000) = (-1)^(1) * 2^(1 - 3) * 0.1000
  // ----------------------------------------------
  //   -0.2343750) = (-1)^(1) * 2^(1 - 3) * 0.1111
  // (-1)^(1) * 2^(0 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1111));
}
drivenby { // case 70
  x = (false@0b000@0b0101);
  y = (true@0b010@0b1000);
  // x + y
  //   +0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   -0.6718750) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // (-1)^(1) * 2^(2 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0110));
}
drivenby { // case 71
  x = (false@0b010@0b1100);
  y = (true@0b000@0b1100);
  // x + y
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // +(-0.1875000) = (-1)^(1) * 2^(1 - 3) * 0.1100
  // ----------------------------------------------
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // (-1)^(0) * 2^(2 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0110));
}
drivenby { // case 72
  x = (false@0b000@0b0110);
  y = (true@0b011@0b1110);
  // x + y
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // +(-1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // ----------------------------------------------
  //   -1.7812500) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // (-1)^(1) * 2^(3 - 3) * 11100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1100));
}
drivenby { // case 73
  x = (false@0b101@0b1101);
  y = (true@0b011@0b0010);
  // x + y
  //   +7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // +(-1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // ----------------------------------------------
  //   +6.1250000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 74
  x = (true@0b010@0b0100);
  y = (true@0b001@0b1101);
  // x + y
  //   -0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // +(-0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   -1.0781250) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // (-1)^(1) * 2^(3 - 3) * 10001 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0001));
}
drivenby { // case 75
  x = (true@0b100@0b1111);
  y = (true@0b001@0b0100);
  // x + y
  //   -3.8750000) = (-1)^(1) * 2^(4 - 3) * 1.1111
  // +(-0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   -4.1875000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 76
  x = (false@0b001@0b1110);
  y = (false@0b010@0b1100);
  // x + y
  //   +0.4687500) = (-1)^(0) * 2^(1 - 3) * 1.1110
  // +(+0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   +1.3437500) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // (-1)^(0) * 2^(3 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0110));
}
drivenby { // case 77
  x = (false@0b010@0b0000);
  y = (false@0b000@0b0001);
  // x + y
  //   +0.5000000) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // +(+0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   +0.5156250) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // (-1)^(0) * 2^(2 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0000));
}
drivenby { // case 78
  x = (true@0b000@0b1101);
  y = (false@0b101@0b0100);
  // x + y
  //   -0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // +(+5.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // ----------------------------------------------
  //   +4.7968750) = (-1)^(0) * 2^(5 - 3) * 1.0011
  // (-1)^(0) * 2^(5 - 3) * 10011 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0011));
}
drivenby { // case 79
  x = (false@0b100@0b1011);
  y = (true@0b010@0b1010);
  // x + y
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // +(-0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // ----------------------------------------------
  //   +2.5625000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // (-1)^(0) * 2^(4 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0100));
}
drivenby { // case 80
  x = (false@0b101@0b1110);
  y = (true@0b001@0b1100);
  // x + y
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // +(-0.4375000) = (-1)^(1) * 2^(1 - 3) * 1.1100
  // ----------------------------------------------
  //   +7.0625000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // (-1)^(0) * 2^(5 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1100));
}
drivenby { // case 81
  x = (true@0b001@0b0011);
  y = (true@0b011@0b0000);
  // x + y
  //   -0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // +(-1.0000000) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // ----------------------------------------------
  //   -1.2968750) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 82
  x = (true@0b001@0b0100);
  y = (true@0b101@0b0100);
  // x + y
  //   -0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // +(-5.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // ----------------------------------------------
  //   -5.3125000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // (-1)^(1) * 2^(5 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0101));
}
drivenby { // case 83
  x = (true@0b010@0b0000);
  y = (false@0b000@0b0100);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(+0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   -0.4375000) = (-1)^(1) * 2^(1 - 3) * 1.1100
  // (-1)^(1) * 2^(1 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1100));
}
drivenby { // case 84
  x = (false@0b101@0b0100);
  y = (true@0b000@0b1010);
  // x + y
  //   +5.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // +(-0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // ----------------------------------------------
  //   +4.8437500) = (-1)^(0) * 2^(5 - 3) * 1.0011
  // (-1)^(0) * 2^(5 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0011));
}
drivenby { // case 85
  x = (false@0b000@0b1100);
  y = (false@0b001@0b1001);
  // x + y
  //   +0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // +(+0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   +0.5781250) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // (-1)^(0) * 2^(2 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0010));
}
drivenby { // case 86
  x = (false@0b001@0b0000);
  y = (false@0b010@0b1001);
  // x + y
  //   +0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // +(+0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   +1.0312500) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 87
  x = (false@0b010@0b1100);
  y = (false@0b101@0b0101);
  // x + y
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // +(+5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   +6.1250000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 88
  x = (true@0b100@0b0100);
  y = (true@0b010@0b0100);
  // x + y
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // +(-0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // ----------------------------------------------
  //   -3.1250000) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // (-1)^(1) * 2^(4 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1001));
}
drivenby { // case 89
  x = (true@0b101@0b1001);
  y = (false@0b000@0b1011);
  // x + y
  //   -6.2500000) = (-1)^(1) * 2^(5 - 3) * 1.1001
  // +(+0.1718750) = (-1)^(0) * 2^(1 - 3) * 0.1011
  // ----------------------------------------------
  //   -6.0781250) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // (-1)^(1) * 2^(5 - 3) * 11000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1000));
}
drivenby { // case 90
  x = (false@0b100@0b1011);
  y = (false@0b001@0b0101);
  // x + y
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // +(+0.3281250) = (-1)^(0) * 2^(1 - 3) * 1.0101
  // ----------------------------------------------
  //   +3.7031250) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // (-1)^(0) * 2^(4 - 3) * 11101 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1110));
}
drivenby { // case 91
  x = (true@0b001@0b1000);
  y = (true@0b001@0b0010);
  // x + y
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // +(-0.2812500) = (-1)^(1) * 2^(1 - 3) * 1.0010
  // ----------------------------------------------
  //   -0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // (-1)^(1) * 2^(2 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0101));
}
drivenby { // case 92
  x = (false@0b011@0b0000);
  y = (false@0b100@0b0010);
  // x + y
  //   +1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +3.2500000) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // (-1)^(0) * 2^(4 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1010));
}
drivenby { // case 93
  x = (false@0b001@0b1010);
  y = (false@0b000@0b1010);
  // x + y
  //   +0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // +(+0.1562500) = (-1)^(0) * 2^(1 - 3) * 0.1010
  // ----------------------------------------------
  //   +0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // (-1)^(0) * 2^(2 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0010));
}
drivenby { // case 94
  x = (false@0b000@0b0011);
  y = (false@0b000@0b1100);
  // x + y
  //   +0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // +(+0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // ----------------------------------------------
  //   +0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // (-1)^(0) * 2^(0 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1111));
}
drivenby { // case 95
  x = (true@0b010@0b0111);
  y = (true@0b001@0b0000);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.9687500) = (-1)^(1) * 2^(2 - 3) * 1.1111
  // (-1)^(1) * 2^(2 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1111));
}
drivenby { // case 96
  x = (false@0b000@0b1111);
  y = (false@0b010@0b1001);
  // x + y
  //   +0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // +(+0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   +1.0156250) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 97
  x = (false@0b000@0b1110);
  y = (true@0b101@0b1110);
  // x + y
  //   +0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // +(-7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   -7.2812500) = (-1)^(1) * 2^(5 - 3) * 1.1101
  // (-1)^(1) * 2^(5 - 3) * 11101 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1101));
}
drivenby { // case 98
  x = (true@0b001@0b0011);
  y = (true@0b101@0b1100);
  // x + y
  //   -0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // +(-7.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // ----------------------------------------------
  //   -7.2968750) = (-1)^(1) * 2^(5 - 3) * 1.1101
  // (-1)^(1) * 2^(5 - 3) * 11101 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1101));
}
drivenby { // case 99
  x = (false@0b011@0b0000);
  y = (false@0b001@0b0100);
  // x + y
  //   +1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   +1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // (-1)^(0) * 2^(3 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0101));
}
drivenby { // case 100
  x = (true@0b011@0b1100);
  y = (false@0b010@0b0001);
  // x + y
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // +(+0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   -1.2187500) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 101
  x = (false@0b010@0b1100);
  y = (true@0b010@0b1100);
  // x + y
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // +(-0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   +0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // (-1)^(0) * 2^(3 - 3) * 00000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0000));
}
drivenby { // case 102
  x = (false@0b010@0b1010);
  y = (true@0b001@0b0011);
  // x + y
  //   +0.8125000) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // +(-0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // ----------------------------------------------
  //   +0.5156250) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // (-1)^(0) * 2^(2 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0000));
}
drivenby { // case 103
  x = (true@0b010@0b1100);
  y = (true@0b010@0b1001);
  // x + y
  //   -0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // +(-0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   -1.6562500) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // (-1)^(1) * 2^(3 - 3) * 11010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1010));
}
drivenby { // case 104
  x = (true@0b000@0b1111);
  y = (true@0b101@0b0110);
  // x + y
  //   -0.2343750) = (-1)^(1) * 2^(1 - 3) * 0.1111
  // +(-5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   -5.7343750) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // (-1)^(1) * 2^(5 - 3) * 10110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0111));
}
drivenby { // case 105
  x = (true@0b010@0b0111);
  y = (true@0b000@0b0110);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(-0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // ----------------------------------------------
  //   -0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // (-1)^(1) * 2^(2 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1010));
}
drivenby { // case 106
  x = (true@0b000@0b0110);
  y = (true@0b101@0b1111);
  // x + y
  //   -0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // +(-7.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // ----------------------------------------------
  //   -7.8437500) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // (-1)^(1) * 2^(5 - 3) * 11111 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1111));
}
drivenby { // case 107
  x = (true@0b100@0b0110);
  y = (true@0b101@0b0001);
  // x + y
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // +(-4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // ----------------------------------------------
  //   -7.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // (-1)^(1) * 2^(5 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1100));
}
drivenby { // case 108
  x = (true@0b100@0b0100);
  y = (true@0b101@0b1000);
  // x + y
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // +(-6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   -8.5000000) = (-1)^(1) * 2^(6 - 3) * 1.0001
  // (-1)^(1) * 2^(6 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0001));
}
drivenby { // case 109
  x = (true@0b100@0b0010);
  y = (false@0b011@0b1001);
  // x + y
  //   -2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // +(+1.5625000) = (-1)^(0) * 2^(3 - 3) * 1.1001
  // ----------------------------------------------
  //   -0.6875000) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // (-1)^(1) * 2^(2 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0110));
}
drivenby { // case 110
  x = (false@0b010@0b0101);
  y = (false@0b000@0b1110);
  // x + y
  //   +0.6562500) = (-1)^(0) * 2^(2 - 3) * 1.0101
  // +(+0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // ----------------------------------------------
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // (-1)^(0) * 2^(2 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1100));
}
drivenby { // case 111
  x = (true@0b101@0b0001);
  y = (true@0b000@0b0000);
  // x + y
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // +(-0.0000000) = (-1)^(1) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 112
  x = (false@0b011@0b0101);
  y = (false@0b000@0b0101);
  // x + y
  //   +1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // +(+0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   +1.3906250) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // (-1)^(0) * 2^(3 - 3) * 10110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0110));
}
drivenby { // case 113
  x = (false@0b101@0b1110);
  y = (false@0b011@0b0110);
  // x + y
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // +(+1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   +8.8750000) = (-1)^(0) * 2^(6 - 3) * 1.0010
  // (-1)^(0) * 2^(6 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0010));
}
drivenby { // case 114
  x = (false@0b100@0b1100);
  y = (false@0b000@0b1001);
  // x + y
  //   +3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // +(+0.1406250) = (-1)^(0) * 2^(1 - 3) * 0.1001
  // ----------------------------------------------
  //   +3.6406250) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // (-1)^(0) * 2^(4 - 3) * 11101 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1101));
}
drivenby { // case 115
  x = (false@0b010@0b1010);
  y = (true@0b000@0b0001);
  // x + y
  //   +0.8125000) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // +(-0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   +0.7968750) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // (-1)^(0) * 2^(2 - 3) * 11001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1010));
}
drivenby { // case 116
  x = (true@0b100@0b1011);
  y = (false@0b101@0b0001);
  // x + y
  //   -3.3750000) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // +(+4.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // (-1)^(0) * 2^(2 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1100));
}
drivenby { // case 117
  x = (true@0b001@0b0000);
  y = (false@0b000@0b0001);
  // x + y
  //   -0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // +(+0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   -0.2343750) = (-1)^(1) * 2^(1 - 3) * 0.1111
  // (-1)^(1) * 2^(0 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1111));
}
drivenby { // case 118
  x = (false@0b010@0b1100);
  y = (true@0b010@0b1001);
  // x + y
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // +(-0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // (-1)^(0) * 2^(-1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0110));
}
drivenby { // case 119
  x = (true@0b010@0b0011);
  y = (true@0b010@0b1001);
  // x + y
  //   -0.5937500) = (-1)^(1) * 2^(2 - 3) * 1.0011
  // +(-0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   -1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // (-1)^(1) * 2^(3 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0110));
}
drivenby { // case 120
  x = (true@0b100@0b0010);
  y = (false@0b100@0b0100);
  // x + y
  //   -2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // +(+2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // ----------------------------------------------
  //   +0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // (-1)^(0) * 2^(1 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0000));
}
drivenby { // case 121
  x = (false@0b011@0b1110);
  y = (false@0b001@0b1101);
  // x + y
  //   +1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // +(+0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   +2.3281250) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // (-1)^(0) * 2^(4 - 3) * 10010 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0011));
}
drivenby { // case 122
  x = (true@0b001@0b0001);
  y = (false@0b101@0b1111);
  // x + y
  //   -0.2656250) = (-1)^(1) * 2^(1 - 3) * 1.0001
  // +(+7.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1111
  // ----------------------------------------------
  //   +7.4843750) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // (-1)^(0) * 2^(5 - 3) * 11101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1110));
}
drivenby { // case 123
  x = (true@0b010@0b1001);
  y = (true@0b011@0b0011);
  // x + y
  //   -0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // +(-1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   -1.9687500) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // (-1)^(1) * 2^(3 - 3) * 11111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0000));
}
drivenby { // case 124
  x = (true@0b000@0b1010);
  y = (false@0b011@0b0001);
  // x + y
  //   -0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // +(+1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // (-1)^(0) * 2^(2 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1101));
}
drivenby { // case 125
  x = (false@0b001@0b0010);
  y = (false@0b101@0b1100);
  // x + y
  //   +0.2812500) = (-1)^(0) * 2^(1 - 3) * 1.0010
  // +(+7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // ----------------------------------------------
  //   +7.2812500) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // (-1)^(0) * 2^(5 - 3) * 11101 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1101));
}
drivenby { // case 126
  x = (false@0b101@0b1101);
  y = (true@0b011@0b0110);
  // x + y
  //   +7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // +(-1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   +5.8750000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 127
  x = (false@0b001@0b1001);
  y = (true@0b101@0b1011);
  // x + y
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // +(-6.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1011
  // ----------------------------------------------
  //   -6.3593750) = (-1)^(1) * 2^(5 - 3) * 1.1001
  // (-1)^(1) * 2^(5 - 3) * 11001 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1001));
}
drivenby { // case 128
  x = (false@0b100@0b0101);
  y = (true@0b011@0b0110);
  // x + y
  //   +2.6250000) = (-1)^(0) * 2^(4 - 3) * 1.0101
  // +(-1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   +1.2500000) = (-1)^(0) * 2^(3 - 3) * 1.0100
  // (-1)^(0) * 2^(3 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0100));
}
drivenby { // case 129
  x = (false@0b010@0b0100);
  y = (true@0b101@0b1011);
  // x + y
  //   +0.6250000) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // +(-6.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1011
  // ----------------------------------------------
  //   -6.1250000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // (-1)^(1) * 2^(5 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1000));
}
drivenby { // case 130
  x = (true@0b101@0b1110);
  y = (true@0b001@0b0111);
  // x + y
  //   -7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // +(-0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // ----------------------------------------------
  //   -7.8593750) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // (-1)^(1) * 2^(5 - 3) * 11111 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1111));
}
drivenby { // case 131
  x = (true@0b001@0b1001);
  y = (false@0b000@0b0111);
  // x + y
  //   -0.3906250) = (-1)^(1) * 2^(1 - 3) * 1.1001
  // +(+0.1093750) = (-1)^(0) * 2^(1 - 3) * 0.0111
  // ----------------------------------------------
  //   -0.2812500) = (-1)^(1) * 2^(1 - 3) * 1.0010
  // (-1)^(1) * 2^(1 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0010));
}
drivenby { // case 132
  x = (false@0b101@0b1001);
  y = (false@0b100@0b1010);
  // x + y
  //   +6.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // +(+3.2500000) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // ----------------------------------------------
  //   +9.5000000) = (-1)^(0) * 2^(6 - 3) * 1.0011
  // (-1)^(0) * 2^(6 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0011));
}
drivenby { // case 133
  x = (true@0b011@0b0100);
  y = (false@0b010@0b0100);
  // x + y
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // +(+0.6250000) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // ----------------------------------------------
  //   -0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // (-1)^(1) * 2^(2 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0100));
}
drivenby { // case 134
  x = (false@0b011@0b0010);
  y = (false@0b100@0b0011);
  // x + y
  //   +1.1250000) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // +(+2.3750000) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // ----------------------------------------------
  //   +3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // (-1)^(0) * 2^(4 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1100));
}
drivenby { // case 135
  x = (true@0b001@0b0000);
  y = (false@0b000@0b0101);
  // x + y
  //   -0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // +(+0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   -0.1718750) = (-1)^(1) * 2^(1 - 3) * 0.1011
  // (-1)^(1) * 2^(0 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1011));
}
drivenby { // case 136
  x = (true@0b001@0b1001);
  y = (false@0b011@0b0111);
  // x + y
  //   -0.3906250) = (-1)^(1) * 2^(1 - 3) * 1.1001
  // +(+1.4375000) = (-1)^(0) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   +1.0468750) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // (-1)^(0) * 2^(3 - 3) * 10000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0001));
}
drivenby { // case 137
  x = (true@0b100@0b0100);
  y = (false@0b000@0b0000);
  // x + y
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // +(+0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 138
  x = (true@0b011@0b1100);
  y = (true@0b101@0b1110);
  // x + y
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // +(-7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   -9.2500000) = (-1)^(1) * 2^(6 - 3) * 1.0010
  // (-1)^(1) * 2^(6 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0010));
}
drivenby { // case 139
  x = (true@0b011@0b1011);
  y = (false@0b001@0b1000);
  // x + y
  //   -1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // +(+0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 140
  x = (true@0b010@0b0101);
  y = (false@0b010@0b0110);
  // x + y
  //   -0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // (-1)^(0) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0010));
}
drivenby { // case 141
  x = (true@0b010@0b0101);
  y = (false@0b100@0b0001);
  // x + y
  //   -0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // +(+2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // ----------------------------------------------
  //   +1.4687500) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // (-1)^(0) * 2^(3 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1000));
}
drivenby { // case 142
  x = (false@0b011@0b1111);
  y = (false@0b010@0b1001);
  // x + y
  //   +1.9375000) = (-1)^(0) * 2^(3 - 3) * 1.1111
  // +(+0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   +2.7187500) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // (-1)^(0) * 2^(4 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0110));
}
drivenby { // case 143
  x = (true@0b101@0b1010);
  y = (true@0b010@0b0111);
  // x + y
  //   -6.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1010
  // +(-0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   -7.2187500) = (-1)^(1) * 2^(5 - 3) * 1.1101
  // (-1)^(1) * 2^(5 - 3) * 11100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1101));
}
drivenby { // case 144
  x = (false@0b010@0b0110);
  y = (true@0b010@0b1011);
  // x + y
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // +(-0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   -0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // (-1)^(1) * 2^(0 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1010));
}
drivenby { // case 145
  x = (true@0b011@0b0001);
  y = (true@0b001@0b1000);
  // x + y
  //   -1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // +(-0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   -1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // (-1)^(1) * 2^(3 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0111));
}
drivenby { // case 146
  x = (true@0b001@0b0110);
  y = (false@0b001@0b0100);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   -0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // (-1)^(1) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0010));
}
drivenby { // case 147
  x = (true@0b101@0b0010);
  y = (false@0b000@0b1100);
  // x + y
  //   -4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // +(+0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // ----------------------------------------------
  //   -4.3125000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10001 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 148
  x = (true@0b011@0b0001);
  y = (true@0b001@0b0001);
  // x + y
  //   -1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // +(-0.2656250) = (-1)^(1) * 2^(1 - 3) * 1.0001
  // ----------------------------------------------
  //   -1.3281250) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 149
  x = (false@0b001@0b1101);
  y = (false@0b000@0b1011);
  // x + y
  //   +0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // +(+0.1718750) = (-1)^(0) * 2^(1 - 3) * 0.1011
  // ----------------------------------------------
  //   +0.6250000) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // (-1)^(0) * 2^(2 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0100));
}
drivenby { // case 150
  x = (true@0b010@0b0011);
  y = (true@0b001@0b0000);
  // x + y
  //   -0.5937500) = (-1)^(1) * 2^(2 - 3) * 1.0011
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // (-1)^(1) * 2^(2 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1011));
}
drivenby { // case 151
  x = (true@0b010@0b1011);
  y = (true@0b000@0b0110);
  // x + y
  //   -0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // +(-0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // ----------------------------------------------
  //   -0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // (-1)^(1) * 2^(2 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1110));
}
drivenby { // case 152
  x = (true@0b000@0b1110);
  y = (true@0b000@0b0111);
  // x + y
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // +(-0.1093750) = (-1)^(1) * 2^(1 - 3) * 0.0111
  // ----------------------------------------------
  //   -0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // (-1)^(1) * 2^(1 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0101));
}
drivenby { // case 153
  x = (true@0b000@0b0010);
  y = (false@0b001@0b1001);
  // x + y
  //   -0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // +(+0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   +0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // (-1)^(0) * 2^(1 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0111));
}
drivenby { // case 154
  x = (false@0b010@0b1100);
  y = (true@0b000@0b0100);
  // x + y
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // +(-0.0625000) = (-1)^(1) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   +0.8125000) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // (-1)^(0) * 2^(2 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1010));
}
drivenby { // case 155
  x = (true@0b010@0b0110);
  y = (false@0b101@0b1011);
  // x + y
  //   -0.6875000) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // +(+6.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1011
  // ----------------------------------------------
  //   +6.0625000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 11000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 156
  x = (false@0b000@0b0110);
  y = (false@0b001@0b0010);
  // x + y
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // +(+0.2812500) = (-1)^(0) * 2^(1 - 3) * 1.0010
  // ----------------------------------------------
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // (-1)^(0) * 2^(1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1000));
}
drivenby { // case 157
  x = (true@0b010@0b1010);
  y = (true@0b000@0b1010);
  // x + y
  //   -0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // +(-0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // ----------------------------------------------
  //   -0.9687500) = (-1)^(1) * 2^(2 - 3) * 1.1111
  // (-1)^(1) * 2^(2 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1111));
}
drivenby { // case 158
  x = (false@0b011@0b1010);
  y = (false@0b010@0b0110);
  // x + y
  //   +1.6250000) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   +2.3125000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // (-1)^(0) * 2^(4 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0010));
}
drivenby { // case 159
  x = (true@0b010@0b1110);
  y = (true@0b101@0b1000);
  // x + y
  //   -0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // +(-6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   -6.9375000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // (-1)^(1) * 2^(5 - 3) * 11011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1100));
}
drivenby { // case 160
  x = (true@0b010@0b0000);
  y = (false@0b000@0b0011);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(+0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // ----------------------------------------------
  //   -0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // (-1)^(1) * 2^(1 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1101));
}
drivenby { // case 161
  x = (true@0b101@0b0101);
  y = (true@0b001@0b0000);
  // x + y
  //   -5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // (-1)^(1) * 2^(5 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0110));
}
drivenby { // case 162
  x = (true@0b100@0b1101);
  y = (true@0b001@0b1101);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(-0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   -4.0781250) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(5 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 163
  x = (true@0b011@0b1000);
  y = (false@0b001@0b0000);
  // x + y
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // +(+0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 164
  x = (false@0b000@0b0011);
  y = (false@0b011@0b1000);
  // x + y
  //   +0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // +(+1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   +1.5468750) = (-1)^(0) * 2^(3 - 3) * 1.1001
  // (-1)^(0) * 2^(3 - 3) * 11000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1001));
}
drivenby { // case 165
  x = (false@0b101@0b1100);
  y = (true@0b011@0b0111);
  // x + y
  //   +7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // +(-1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   +5.5625000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 166
  x = (false@0b000@0b1100);
  y = (false@0b001@0b1011);
  // x + y
  //   +0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // +(+0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.6093750) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // (-1)^(0) * 2^(2 - 3) * 10011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0100));
}
drivenby { // case 167
  x = (false@0b100@0b1101);
  y = (true@0b101@0b1010);
  // x + y
  //   +3.6250000) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // +(-6.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   -2.8750000) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // (-1)^(1) * 2^(4 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0111));
}
drivenby { // case 168
  x = (false@0b101@0b0010);
  y = (true@0b101@0b0111);
  // x + y
  //   +4.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // +(-5.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // ----------------------------------------------
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 169
  x = (true@0b101@0b0100);
  y = (false@0b001@0b0011);
  // x + y
  //   -5.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // +(+0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // ----------------------------------------------
  //   -4.7031250) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // (-1)^(1) * 2^(5 - 3) * 10010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0011));
}
drivenby { // case 170
  x = (false@0b001@0b1110);
  y = (false@0b000@0b1101);
  // x + y
  //   +0.4687500) = (-1)^(0) * 2^(1 - 3) * 1.1110
  // +(+0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   +0.6718750) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // (-1)^(0) * 2^(2 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0110));
}
drivenby { // case 171
  x = (true@0b011@0b0110);
  y = (true@0b001@0b1011);
  // x + y
  //   -1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // +(-0.4218750) = (-1)^(1) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   -1.7968750) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // (-1)^(1) * 2^(3 - 3) * 11100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1101));
}
drivenby { // case 172
  x = (false@0b101@0b1110);
  y = (true@0b011@0b0111);
  // x + y
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // +(-1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   +6.0625000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 11000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 173
  x = (false@0b011@0b1100);
  y = (false@0b100@0b0111);
  // x + y
  //   +1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // +(+2.8750000) = (-1)^(0) * 2^(4 - 3) * 1.0111
  // ----------------------------------------------
  //   +4.6250000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // (-1)^(0) * 2^(5 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0010));
}
drivenby { // case 174
  x = (true@0b100@0b1110);
  y = (true@0b100@0b1111);
  // x + y
  //   -3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // +(-3.8750000) = (-1)^(1) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   -7.6250000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // (-1)^(1) * 2^(5 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1110));
}
drivenby { // case 175
  x = (true@0b010@0b0011);
  y = (true@0b000@0b0100);
  // x + y
  //   -0.5937500) = (-1)^(1) * 2^(2 - 3) * 1.0011
  // +(-0.0625000) = (-1)^(1) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   -0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // (-1)^(1) * 2^(2 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0101));
}
drivenby { // case 176
  x = (true@0b100@0b1010);
  y = (true@0b001@0b1011);
  // x + y
  //   -3.2500000) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // +(-0.4218750) = (-1)^(1) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   -3.6718750) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // (-1)^(1) * 2^(4 - 3) * 11101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1101));
}
drivenby { // case 177
  x = (false@0b010@0b1101);
  y = (false@0b001@0b1100);
  // x + y
  //   +0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // +(+0.4375000) = (-1)^(0) * 2^(1 - 3) * 1.1100
  // ----------------------------------------------
  //   +1.3437500) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // (-1)^(0) * 2^(3 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0110));
}
drivenby { // case 178
  x = (false@0b011@0b0101);
  y = (false@0b101@0b0010);
  // x + y
  //   +1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // +(+4.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // ----------------------------------------------
  //   +5.8125000) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // (-1)^(0) * 2^(5 - 3) * 10111 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0111));
}
drivenby { // case 179
  x = (false@0b011@0b0010);
  y = (false@0b100@0b1100);
  // x + y
  //   +1.1250000) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // +(+3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // ----------------------------------------------
  //   +4.6250000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // (-1)^(0) * 2^(5 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0010));
}
drivenby { // case 180
  x = (false@0b011@0b1000);
  y = (true@0b101@0b0010);
  // x + y
  //   +1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // +(-4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // ----------------------------------------------
  //   -3.0000000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // (-1)^(1) * 2^(4 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1000));
}
drivenby { // case 181
  x = (false@0b000@0b1001);
  y = (true@0b101@0b0000);
  // x + y
  //   +0.1406250) = (-1)^(0) * 2^(1 - 3) * 0.1001
  // +(-4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   -3.8593750) = (-1)^(1) * 2^(4 - 3) * 1.1111
  // (-1)^(1) * 2^(4 - 3) * 11110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1111));
}
drivenby { // case 182
  x = (false@0b011@0b0110);
  y = (true@0b100@0b0001);
  // x + y
  //   +1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // +(-2.1250000) = (-1)^(1) * 2^(4 - 3) * 1.0001
  // ----------------------------------------------
  //   -0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // (-1)^(1) * 2^(2 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1000));
}
drivenby { // case 183
  x = (true@0b100@0b1101);
  y = (true@0b000@0b0101);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(-0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   -3.7031250) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // (-1)^(1) * 2^(4 - 3) * 11101 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1110));
}
drivenby { // case 184
  x = (true@0b100@0b0001);
  y = (true@0b011@0b0110);
  // x + y
  //   -2.1250000) = (-1)^(1) * 2^(4 - 3) * 1.0001
  // +(-1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   -3.5000000) = (-1)^(1) * 2^(4 - 3) * 1.1100
  // (-1)^(1) * 2^(4 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1100));
}
drivenby { // case 185
  x = (true@0b001@0b1011);
  y = (true@0b010@0b0000);
  // x + y
  //   -0.4218750) = (-1)^(1) * 2^(1 - 3) * 1.1011
  // +(-0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.9218750) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // (-1)^(1) * 2^(2 - 3) * 11101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1110));
}
drivenby { // case 186
  x = (true@0b010@0b0000);
  y = (false@0b101@0b0001);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(+4.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0001
  // ----------------------------------------------
  //   +3.7500000) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // (-1)^(0) * 2^(4 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1110));
}
drivenby { // case 187
  x = (false@0b000@0b1111);
  y = (false@0b001@0b0111);
  // x + y
  //   +0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // +(+0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // ----------------------------------------------
  //   +0.5937500) = (-1)^(0) * 2^(2 - 3) * 1.0011
  // (-1)^(0) * 2^(2 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0011));
}
drivenby { // case 188
  x = (true@0b101@0b0001);
  y = (false@0b100@0b1001);
  // x + y
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // +(+3.1250000) = (-1)^(0) * 2^(4 - 3) * 1.1001
  // ----------------------------------------------
  //   -1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // (-1)^(1) * 2^(3 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0010));
}
drivenby { // case 189
  x = (true@0b001@0b1000);
  y = (false@0b010@0b1011);
  // x + y
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // +(+0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.4687500) = (-1)^(0) * 2^(1 - 3) * 1.1110
  // (-1)^(0) * 2^(1 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1110));
}
drivenby { // case 190
  x = (false@0b101@0b0010);
  y = (false@0b010@0b0000);
  // x + y
  //   +4.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // +(+0.5000000) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   +5.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 191
  x = (false@0b101@0b1110);
  y = (true@0b001@0b1000);
  // x + y
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // +(-0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   +7.1250000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // (-1)^(0) * 2^(5 - 3) * 11100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1100));
}
drivenby { // case 192
  x = (false@0b001@0b1000);
  y = (true@0b101@0b1011);
  // x + y
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // +(-6.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1011
  // ----------------------------------------------
  //   -6.3750000) = (-1)^(1) * 2^(5 - 3) * 1.1010
  // (-1)^(1) * 2^(5 - 3) * 11001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1010));
}
drivenby { // case 193
  x = (false@0b001@0b1110);
  y = (true@0b101@0b0110);
  // x + y
  //   +0.4687500) = (-1)^(0) * 2^(1 - 3) * 1.1110
  // +(-5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   -5.0312500) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // (-1)^(1) * 2^(5 - 3) * 10100 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0100));
}
drivenby { // case 194
  x = (true@0b100@0b0101);
  y = (true@0b101@0b1101);
  // x + y
  //   -2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // +(-7.2500000) = (-1)^(1) * 2^(5 - 3) * 1.1101
  // ----------------------------------------------
  //   -9.8750000) = (-1)^(1) * 2^(6 - 3) * 1.0100
  // (-1)^(1) * 2^(6 - 3) * 10011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0100));
}
drivenby { // case 195
  x = (false@0b101@0b1010);
  y = (false@0b001@0b0100);
  // x + y
  //   +6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   +6.8125000) = (-1)^(0) * 2^(5 - 3) * 1.1011
  // (-1)^(0) * 2^(5 - 3) * 11011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1011));
}
drivenby { // case 196
  x = (false@0b100@0b1110);
  y = (false@0b101@0b1001);
  // x + y
  //   +3.7500000) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // +(+6.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // ----------------------------------------------
  //   +10.0000000) = (-1)^(0) * 2^(6 - 3) * 1.0100
  // (-1)^(0) * 2^(6 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0100));
}
drivenby { // case 197
  x = (false@0b101@0b0111);
  y = (false@0b011@0b1100);
  // x + y
  //   +5.7500000) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // +(+1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // (-1)^(0) * 2^(5 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1110));
}
drivenby { // case 198
  x = (false@0b001@0b1011);
  y = (false@0b101@0b0001);
  // x + y
  //   +0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // +(+4.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0001
  // ----------------------------------------------
  //   +4.6718750) = (-1)^(0) * 2^(5 - 3) * 1.0011
  // (-1)^(0) * 2^(5 - 3) * 10010 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0011));
}
drivenby { // case 199
  x = (true@0b100@0b0111);
  y = (false@0b011@0b0000);
  // x + y
  //   -2.8750000) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // +(+1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // ----------------------------------------------
  //   -1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // (-1)^(1) * 2^(3 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1110));
}
drivenby { // case 200
  x = (false@0b101@0b0010);
  y = (false@0b001@0b0111);
  // x + y
  //   +4.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // +(+0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // ----------------------------------------------
  //   +4.8593750) = (-1)^(0) * 2^(5 - 3) * 1.0011
  // (-1)^(0) * 2^(5 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0011));
}
drivenby { // case 201
  x = (true@0b001@0b0001);
  y = (true@0b001@0b0000);
  // x + y
  //   -0.2656250) = (-1)^(1) * 2^(1 - 3) * 1.0001
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.5156250) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // (-1)^(1) * 2^(2 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0000));
}
drivenby { // case 202
  x = (false@0b010@0b0110);
  y = (true@0b000@0b0000);
  // x + y
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // +(-0.0000000) = (-1)^(1) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // (-1)^(0) * 2^(2 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0110));
}
drivenby { // case 203
  x = (false@0b010@0b1000);
  y = (true@0b011@0b1101);
  // x + y
  //   +0.7500000) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // +(-1.8125000) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // ----------------------------------------------
  //   -1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // (-1)^(1) * 2^(3 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0001));
}
drivenby { // case 204
  x = (false@0b010@0b1001);
  y = (false@0b010@0b0100);
  // x + y
  //   +0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // +(+0.6250000) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // ----------------------------------------------
  //   +1.4062500) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // (-1)^(0) * 2^(3 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0110));
}
drivenby { // case 205
  x = (false@0b000@0b1100);
  y = (false@0b101@0b1010);
  // x + y
  //   +0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +6.6875000) = (-1)^(0) * 2^(5 - 3) * 1.1011
  // (-1)^(0) * 2^(5 - 3) * 11010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1011));
}
drivenby { // case 206
  x = (false@0b010@0b0111);
  y = (true@0b001@0b1111);
  // x + y
  //   +0.7187500) = (-1)^(0) * 2^(2 - 3) * 1.0111
  // +(-0.4843750) = (-1)^(1) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   +0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // (-1)^(0) * 2^(0 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1111));
}
drivenby { // case 207
  x = (false@0b001@0b1001);
  y = (false@0b101@0b1101);
  // x + y
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // +(+7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // ----------------------------------------------
  //   +7.6406250) = (-1)^(0) * 2^(5 - 3) * 1.1111
  // (-1)^(0) * 2^(5 - 3) * 11110 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1111));
}
drivenby { // case 208
  x = (true@0b001@0b1000);
  y = (true@0b100@0b0111);
  // x + y
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // +(-2.8750000) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // ----------------------------------------------
  //   -3.2500000) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // (-1)^(1) * 2^(4 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1010));
}
drivenby { // case 209
  x = (true@0b101@0b0001);
  y = (false@0b011@0b1011);
  // x + y
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // +(+1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   -2.5625000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 210
  x = (true@0b001@0b0100);
  y = (false@0b100@0b0101);
  // x + y
  //   -0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // +(+2.6250000) = (-1)^(0) * 2^(4 - 3) * 1.0101
  // ----------------------------------------------
  //   +2.3125000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // (-1)^(0) * 2^(4 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0010));
}
drivenby { // case 211
  x = (true@0b100@0b0011);
  y = (false@0b101@0b1100);
  // x + y
  //   -2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // +(+7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // ----------------------------------------------
  //   +4.6250000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // (-1)^(0) * 2^(5 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0010));
}
drivenby { // case 212
  x = (true@0b011@0b1001);
  y = (false@0b001@0b0010);
  // x + y
  //   -1.5625000) = (-1)^(1) * 2^(3 - 3) * 1.1001
  // +(+0.2812500) = (-1)^(0) * 2^(1 - 3) * 1.0010
  // ----------------------------------------------
  //   -1.2812500) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 213
  x = (false@0b010@0b0011);
  y = (false@0b100@0b1000);
  // x + y
  //   +0.5937500) = (-1)^(0) * 2^(2 - 3) * 1.0011
  // +(+3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // ----------------------------------------------
  //   +3.5937500) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // (-1)^(0) * 2^(4 - 3) * 11100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1101));
}
drivenby { // case 214
  x = (true@0b011@0b0001);
  y = (false@0b011@0b0110);
  // x + y
  //   -1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // +(+1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   +0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // (-1)^(0) * 2^(1 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0100));
}
drivenby { // case 215
  x = (true@0b000@0b0011);
  y = (true@0b011@0b0111);
  // x + y
  //   -0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // +(-1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   -1.4843750) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // (-1)^(1) * 2^(3 - 3) * 10111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1000));
}
drivenby { // case 216
  x = (false@0b100@0b1101);
  y = (true@0b000@0b0101);
  // x + y
  //   +3.6250000) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // +(-0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   +3.5468750) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // (-1)^(0) * 2^(4 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1100));
}
drivenby { // case 217
  x = (true@0b100@0b0000);
  y = (true@0b000@0b0010);
  // x + y
  //   -2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // +(-0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // ----------------------------------------------
  //   -2.0312500) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // (-1)^(1) * 2^(4 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0000));
}
drivenby { // case 218
  x = (true@0b010@0b0110);
  y = (true@0b100@0b0000);
  // x + y
  //   -0.6875000) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // +(-2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // ----------------------------------------------
  //   -2.6875000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 219
  x = (true@0b101@0b1111);
  y = (false@0b001@0b1101);
  // x + y
  //   -7.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // +(+0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   -7.2968750) = (-1)^(1) * 2^(5 - 3) * 1.1101
  // (-1)^(1) * 2^(5 - 3) * 11101 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1101));
}
drivenby { // case 220
  x = (false@0b011@0b1101);
  y = (true@0b000@0b0101);
  // x + y
  //   +1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // +(-0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   +1.7343750) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // (-1)^(0) * 2^(3 - 3) * 11011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1100));
}
drivenby { // case 221
  x = (true@0b101@0b1110);
  y = (false@0b000@0b1000);
  // x + y
  //   -7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // +(+0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // ----------------------------------------------
  //   -7.3750000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // (-1)^(1) * 2^(5 - 3) * 11101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1110));
}
drivenby { // case 222
  x = (true@0b000@0b1000);
  y = (false@0b011@0b0111);
  // x + y
  //   -0.1250000) = (-1)^(1) * 2^(1 - 3) * 0.1000
  // +(+1.4375000) = (-1)^(0) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   +1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // (-1)^(0) * 2^(3 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0101));
}
drivenby { // case 223
  x = (false@0b100@0b0010);
  y = (false@0b001@0b1000);
  // x + y
  //   +2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // +(+0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   +2.6250000) = (-1)^(0) * 2^(4 - 3) * 1.0101
  // (-1)^(0) * 2^(4 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0101));
}
drivenby { // case 224
  x = (true@0b000@0b1001);
  y = (false@0b010@0b1111);
  // x + y
  //   -0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // +(+0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   +0.8281250) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // (-1)^(0) * 2^(2 - 3) * 11010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1010));
}
drivenby { // case 225
  x = (true@0b100@0b1100);
  y = (true@0b010@0b1101);
  // x + y
  //   -3.5000000) = (-1)^(1) * 2^(4 - 3) * 1.1100
  // +(-0.9062500) = (-1)^(1) * 2^(2 - 3) * 1.1101
  // ----------------------------------------------
  //   -4.4062500) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10001 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 226
  x = (true@0b011@0b0110);
  y = (false@0b101@0b1010);
  // x + y
  //   -1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +5.1250000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 227
  x = (true@0b001@0b0110);
  y = (false@0b011@0b0011);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(+1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   +0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // (-1)^(0) * 2^(2 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1011));
}
drivenby { // case 228
  x = (true@0b101@0b0100);
  y = (true@0b011@0b1011);
  // x + y
  //   -5.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // +(-1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   -6.6875000) = (-1)^(1) * 2^(5 - 3) * 1.1011
  // (-1)^(1) * 2^(5 - 3) * 11010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1011));
}
drivenby { // case 229
  x = (false@0b000@0b0001);
  y = (false@0b101@0b1000);
  // x + y
  //   +0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // +(+6.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   +6.0156250) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 11000 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 230
  x = (true@0b100@0b0101);
  y = (false@0b101@0b1111);
  // x + y
  //   -2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // +(+7.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1111
  // ----------------------------------------------
  //   +5.1250000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 231
  x = (true@0b011@0b1110);
  y = (true@0b101@0b1111);
  // x + y
  //   -1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // +(-7.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // ----------------------------------------------
  //   -9.6250000) = (-1)^(1) * 2^(6 - 3) * 1.0011
  // (-1)^(1) * 2^(6 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0011));
}
drivenby { // case 232
  x = (true@0b010@0b1110);
  y = (false@0b100@0b1011);
  // x + y
  //   -0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // +(+3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   +2.4375000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // (-1)^(0) * 2^(4 - 3) * 10011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0100));
}
drivenby { // case 233
  x = (true@0b001@0b1010);
  y = (true@0b011@0b0010);
  // x + y
  //   -0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // +(-1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // ----------------------------------------------
  //   -1.5312500) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // (-1)^(1) * 2^(3 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1000));
}
drivenby { // case 234
  x = (true@0b101@0b0010);
  y = (true@0b101@0b1011);
  // x + y
  //   -4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // +(-6.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1011
  // ----------------------------------------------
  //   -11.2500000) = (-1)^(1) * 2^(6 - 3) * 1.0110
  // (-1)^(1) * 2^(6 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0110));
}
drivenby { // case 235
  x = (true@0b100@0b1010);
  y = (false@0b010@0b1011);
  // x + y
  //   -3.2500000) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // +(+0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   -2.4062500) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // (-1)^(1) * 2^(4 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0011));
}
drivenby { // case 236
  x = (true@0b001@0b1010);
  y = (true@0b000@0b1010);
  // x + y
  //   -0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // +(-0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // ----------------------------------------------
  //   -0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // (-1)^(1) * 2^(2 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0010));
}
drivenby { // case 237
  x = (true@0b100@0b1101);
  y = (true@0b010@0b0011);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(-0.5937500) = (-1)^(1) * 2^(2 - 3) * 1.0011
  // ----------------------------------------------
  //   -4.2187500) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 238
  x = (true@0b101@0b1111);
  y = (true@0b001@0b0010);
  // x + y
  //   -7.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // +(-0.2812500) = (-1)^(1) * 2^(1 - 3) * 1.0010
  // ----------------------------------------------
  //   -8.0312500) = (-1)^(1) * 2^(6 - 3) * 1.0000
  // (-1)^(1) * 2^(6 - 3) * 10000 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0000));
}
drivenby { // case 239
  x = (true@0b100@0b0101);
  y = (false@0b001@0b1010);
  // x + y
  //   -2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // +(+0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // ----------------------------------------------
  //   -2.2187500) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // (-1)^(1) * 2^(4 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0010));
}
drivenby { // case 240
  x = (true@0b010@0b0000);
  y = (true@0b001@0b0101);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(-0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // ----------------------------------------------
  //   -0.8281250) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // (-1)^(1) * 2^(2 - 3) * 11010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1010));
}
drivenby { // case 241
  x = (true@0b100@0b0100);
  y = (true@0b010@0b0101);
  // x + y
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // +(-0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // ----------------------------------------------
  //   -3.1562500) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // (-1)^(1) * 2^(4 - 3) * 11001 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1001));
}
drivenby { // case 242
  x = (true@0b101@0b0001);
  y = (false@0b010@0b1111);
  // x + y
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // +(+0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   -3.2812500) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // (-1)^(1) * 2^(4 - 3) * 11010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1010));
}
drivenby { // case 243
  x = (false@0b101@0b0010);
  y = (true@0b011@0b1111);
  // x + y
  //   +4.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // +(-1.9375000) = (-1)^(1) * 2^(3 - 3) * 1.1111
  // ----------------------------------------------
  //   +2.5625000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // (-1)^(0) * 2^(4 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0100));
}
drivenby { // case 244
  x = (true@0b010@0b0001);
  y = (false@0b010@0b1010);
  // x + y
  //   -0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // +(+0.8125000) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // ----------------------------------------------
  //   +0.2812500) = (-1)^(0) * 2^(1 - 3) * 1.0010
  // (-1)^(0) * 2^(1 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0010));
}
drivenby { // case 245
  x = (false@0b000@0b1001);
  y = (false@0b001@0b0000);
  // x + y
  //   +0.1406250) = (-1)^(0) * 2^(1 - 3) * 0.1001
  // +(+0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // (-1)^(0) * 2^(1 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1001));
}
drivenby { // case 246
  x = (true@0b010@0b0000);
  y = (false@0b000@0b1001);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(+0.1406250) = (-1)^(0) * 2^(1 - 3) * 0.1001
  // ----------------------------------------------
  //   -0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // (-1)^(1) * 2^(1 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0111));
}
drivenby { // case 247
  x = (true@0b101@0b0101);
  y = (false@0b011@0b1000);
  // x + y
  //   -5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // +(+1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   -3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // (-1)^(1) * 2^(4 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1110));
}
drivenby { // case 248
  x = (true@0b011@0b0101);
  y = (true@0b010@0b1000);
  // x + y
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   -2.0625000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // (-1)^(1) * 2^(4 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0000));
}
drivenby { // case 249
  x = (true@0b011@0b0011);
  y = (false@0b101@0b0111);
  // x + y
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // +(+5.7500000) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // ----------------------------------------------
  //   +4.5625000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // (-1)^(0) * 2^(5 - 3) * 10010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0010));
}
drivenby { // case 250
  x = (true@0b101@0b0001);
  y = (false@0b010@0b1011);
  // x + y
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // +(+0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   -3.4062500) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // (-1)^(1) * 2^(4 - 3) * 11011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1011));
}
drivenby { // case 251
  x = (false@0b001@0b1111);
  y = (false@0b001@0b1001);
  // x + y
  //   +0.4843750) = (-1)^(0) * 2^(1 - 3) * 1.1111
  // +(+0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // (-1)^(0) * 2^(2 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1100));
}
drivenby { // case 252
  x = (true@0b100@0b1110);
  y = (false@0b000@0b0110);
  // x + y
  //   -3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // +(+0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // ----------------------------------------------
  //   -3.6562500) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // (-1)^(1) * 2^(4 - 3) * 11101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1101));
}
drivenby { // case 253
  x = (false@0b011@0b0101);
  y = (false@0b011@0b1010);
  // x + y
  //   +1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // +(+1.6250000) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // ----------------------------------------------
  //   +2.9375000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // (-1)^(0) * 2^(4 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1000));
}
drivenby { // case 254
  x = (false@0b100@0b1011);
  y = (true@0b100@0b1111);
  // x + y
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // +(-3.8750000) = (-1)^(1) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // (-1)^(1) * 2^(2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0000));
}
drivenby { // case 255
  x = (true@0b011@0b1110);
  y = (false@0b101@0b1010);
  // x + y
  //   -1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +4.6250000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // (-1)^(0) * 2^(5 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0010));
}
drivenby { // case 256
  x = (true@0b001@0b1000);
  y = (true@0b100@0b1011);
  // x + y
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // +(-3.3750000) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   -3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // (-1)^(1) * 2^(4 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1110));
}
drivenby { // case 257
  x = (false@0b101@0b1010);
  y = (true@0b101@0b0100);
  // x + y
  //   +6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // +(-5.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // ----------------------------------------------
  //   +1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // (-1)^(0) * 2^(3 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1000));
}
drivenby { // case 258
  x = (true@0b000@0b1101);
  y = (false@0b000@0b1110);
  // x + y
  //   -0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // +(+0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // ----------------------------------------------
  //   +0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // (-1)^(0) * 2^(-3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0001));
}
drivenby { // case 259
  x = (false@0b010@0b1101);
  y = (false@0b000@0b1101);
  // x + y
  //   +0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // +(+0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   +1.1093750) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // (-1)^(0) * 2^(3 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0010));
}
drivenby { // case 260
  x = (true@0b101@0b0011);
  y = (true@0b101@0b0110);
  // x + y
  //   -4.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // +(-5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   -10.2500000) = (-1)^(1) * 2^(6 - 3) * 1.0100
  // (-1)^(1) * 2^(6 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0100));
}
drivenby { // case 261
  x = (false@0b101@0b0110);
  y = (false@0b100@0b0010);
  // x + y
  //   +5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +7.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1111
  // (-1)^(0) * 2^(5 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1111));
}
drivenby { // case 262
  x = (true@0b100@0b1101);
  y = (true@0b001@0b1100);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(-0.4375000) = (-1)^(1) * 2^(1 - 3) * 1.1100
  // ----------------------------------------------
  //   -4.0625000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(5 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 263
  x = (false@0b000@0b0100);
  y = (false@0b001@0b0110);
  // x + y
  //   +0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // +(+0.3437500) = (-1)^(0) * 2^(1 - 3) * 1.0110
  // ----------------------------------------------
  //   +0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // (-1)^(0) * 2^(1 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1010));
}
drivenby { // case 264
  x = (true@0b101@0b1111);
  y = (false@0b101@0b0101);
  // x + y
  //   -7.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // +(+5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 265
  x = (true@0b010@0b0000);
  y = (false@0b010@0b0001);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(+0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // (-1)^(0) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0010));
}
drivenby { // case 266
  x = (true@0b000@0b0010);
  y = (true@0b010@0b1000);
  // x + y
  //   -0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   -0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // (-1)^(1) * 2^(2 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1001));
}
drivenby { // case 267
  x = (true@0b011@0b0111);
  y = (false@0b101@0b1110);
  // x + y
  //   -1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // +(+7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   +6.0625000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 11000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 268
  x = (false@0b011@0b1011);
  y = (true@0b011@0b0010);
  // x + y
  //   +1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // +(-1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // ----------------------------------------------
  //   +0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // (-1)^(0) * 2^(2 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0010));
}
drivenby { // case 269
  x = (true@0b100@0b1101);
  y = (false@0b010@0b1001);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(+0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   -2.8437500) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // (-1)^(1) * 2^(4 - 3) * 10110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0111));
}
drivenby { // case 270
  x = (true@0b011@0b0011);
  y = (true@0b010@0b1011);
  // x + y
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // +(-0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   -2.0312500) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // (-1)^(1) * 2^(4 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0000));
}
drivenby { // case 271
  x = (true@0b011@0b1011);
  y = (true@0b010@0b1011);
  // x + y
  //   -1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // +(-0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   -2.5312500) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 272
  x = (false@0b101@0b0111);
  y = (true@0b001@0b1000);
  // x + y
  //   +5.7500000) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // +(-0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   +5.3750000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 273
  x = (true@0b011@0b0011);
  y = (false@0b010@0b0010);
  // x + y
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // +(+0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // ----------------------------------------------
  //   -0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // (-1)^(1) * 2^(2 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0100));
}
drivenby { // case 274
  x = (false@0b010@0b0010);
  y = (false@0b010@0b0000);
  // x + y
  //   +0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // +(+0.5000000) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   +1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // (-1)^(0) * 2^(3 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0001));
}
drivenby { // case 275
  x = (true@0b000@0b0011);
  y = (false@0b001@0b1011);
  // x + y
  //   -0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // +(+0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // (-1)^(0) * 2^(1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1000));
}
drivenby { // case 276
  x = (false@0b000@0b0001);
  y = (true@0b000@0b1001);
  // x + y
  //   +0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // +(-0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // ----------------------------------------------
  //   -0.1250000) = (-1)^(1) * 2^(1 - 3) * 0.1000
  // (-1)^(1) * 2^(0 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1000));
}
drivenby { // case 277
  x = (true@0b000@0b1110);
  y = (false@0b001@0b0000);
  // x + y
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // +(+0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // (-1)^(0) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0010));
}
drivenby { // case 278
  x = (false@0b010@0b1000);
  y = (true@0b101@0b1100);
  // x + y
  //   +0.7500000) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // +(-7.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // ----------------------------------------------
  //   -6.2500000) = (-1)^(1) * 2^(5 - 3) * 1.1001
  // (-1)^(1) * 2^(5 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1001));
}
drivenby { // case 279
  x = (true@0b011@0b0100);
  y = (true@0b001@0b1111);
  // x + y
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // +(-0.4843750) = (-1)^(1) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   -1.7343750) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // (-1)^(1) * 2^(3 - 3) * 11011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1100));
}
drivenby { // case 280
  x = (true@0b100@0b0001);
  y = (false@0b101@0b1010);
  // x + y
  //   -2.1250000) = (-1)^(1) * 2^(4 - 3) * 1.0001
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +4.3750000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // (-1)^(0) * 2^(5 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0010));
}
drivenby { // case 281
  x = (false@0b011@0b1101);
  y = (false@0b000@0b0110);
  // x + y
  //   +1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // +(+0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // ----------------------------------------------
  //   +1.9062500) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // (-1)^(0) * 2^(3 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1110));
}
drivenby { // case 282
  x = (true@0b101@0b0011);
  y = (false@0b011@0b0110);
  // x + y
  //   -4.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // +(+1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   -3.3750000) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // (-1)^(1) * 2^(4 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1011));
}
drivenby { // case 283
  x = (true@0b011@0b0100);
  y = (true@0b100@0b1001);
  // x + y
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // +(-3.1250000) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // ----------------------------------------------
  //   -4.3750000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 284
  x = (true@0b101@0b0111);
  y = (false@0b100@0b1010);
  // x + y
  //   -5.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // +(+3.2500000) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // ----------------------------------------------
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 285
  x = (true@0b011@0b1101);
  y = (false@0b010@0b0010);
  // x + y
  //   -1.8125000) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // +(+0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // ----------------------------------------------
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 286
  x = (false@0b000@0b0010);
  y = (true@0b000@0b1000);
  // x + y
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // +(-0.1250000) = (-1)^(1) * 2^(1 - 3) * 0.1000
  // ----------------------------------------------
  //   -0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // (-1)^(1) * 2^(-1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0110));
}
drivenby { // case 287
  x = (false@0b001@0b0011);
  y = (true@0b100@0b0000);
  // x + y
  //   +0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // +(-2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // ----------------------------------------------
  //   -1.7031250) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // (-1)^(1) * 2^(3 - 3) * 11011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1011));
}
drivenby { // case 288
  x = (true@0b011@0b0010);
  y = (false@0b000@0b0101);
  // x + y
  //   -1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // +(+0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   -1.0468750) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // (-1)^(1) * 2^(3 - 3) * 10000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0001));
}
drivenby { // case 289
  x = (true@0b011@0b1100);
  y = (false@0b011@0b1000);
  // x + y
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // +(+1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   -0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // (-1)^(1) * 2^(1 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0000));
}
drivenby { // case 290
  x = (true@0b010@0b0000);
  y = (false@0b010@0b1010);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(+0.8125000) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // ----------------------------------------------
  //   +0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // (-1)^(0) * 2^(1 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0100));
}
drivenby { // case 291
  x = (false@0b001@0b0010);
  y = (true@0b010@0b1010);
  // x + y
  //   +0.2812500) = (-1)^(0) * 2^(1 - 3) * 1.0010
  // +(-0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // ----------------------------------------------
  //   -0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // (-1)^(1) * 2^(2 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0001));
}
drivenby { // case 292
  x = (false@0b101@0b0110);
  y = (true@0b010@0b0010);
  // x + y
  //   +5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // +(-0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // ----------------------------------------------
  //   +4.9375000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 293
  x = (false@0b000@0b1111);
  y = (false@0b100@0b0101);
  // x + y
  //   +0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // +(+2.6250000) = (-1)^(0) * 2^(4 - 3) * 1.0101
  // ----------------------------------------------
  //   +2.8593750) = (-1)^(0) * 2^(4 - 3) * 1.0111
  // (-1)^(0) * 2^(4 - 3) * 10110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0111));
}
drivenby { // case 294
  x = (false@0b101@0b0000);
  y = (false@0b100@0b0110);
  // x + y
  //   +4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // +(+2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // ----------------------------------------------
  //   +6.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1011
  // (-1)^(0) * 2^(5 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1011));
}
drivenby { // case 295
  x = (true@0b001@0b0100);
  y = (true@0b011@0b1101);
  // x + y
  //   -0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // +(-1.8125000) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // ----------------------------------------------
  //   -2.1250000) = (-1)^(1) * 2^(4 - 3) * 1.0001
  // (-1)^(1) * 2^(4 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0001));
}
drivenby { // case 296
  x = (true@0b011@0b1010);
  y = (true@0b010@0b1000);
  // x + y
  //   -1.6250000) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   -2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // (-1)^(1) * 2^(4 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0011));
}
drivenby { // case 297
  x = (true@0b100@0b0101);
  y = (true@0b000@0b0010);
  // x + y
  //   -2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // +(-0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // ----------------------------------------------
  //   -2.6562500) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // (-1)^(1) * 2^(4 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0101));
}
drivenby { // case 298
  x = (true@0b100@0b1010);
  y = (false@0b010@0b1100);
  // x + y
  //   -3.2500000) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // +(+0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   -2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // (-1)^(1) * 2^(4 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0011));
}
drivenby { // case 299
  x = (true@0b000@0b1001);
  y = (false@0b001@0b0111);
  // x + y
  //   -0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // +(+0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // ----------------------------------------------
  //   +0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // (-1)^(0) * 2^(0 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1110));
}
drivenby { // case 300
  x = (false@0b010@0b0010);
  y = (false@0b001@0b0001);
  // x + y
  //   +0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // +(+0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.8281250) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // (-1)^(0) * 2^(2 - 3) * 11010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1010));
}
drivenby { // case 301
  x = (true@0b100@0b0110);
  y = (true@0b001@0b0110);
  // x + y
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // +(-0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // ----------------------------------------------
  //   -3.0937500) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // (-1)^(1) * 2^(4 - 3) * 11000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1001));
}
drivenby { // case 302
  x = (false@0b100@0b0011);
  y = (true@0b000@0b1111);
  // x + y
  //   +2.3750000) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // +(-0.2343750) = (-1)^(1) * 2^(1 - 3) * 0.1111
  // ----------------------------------------------
  //   +2.1406250) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // (-1)^(0) * 2^(4 - 3) * 10001 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0001));
}
drivenby { // case 303
  x = (true@0b001@0b1011);
  y = (true@0b010@0b1001);
  // x + y
  //   -0.4218750) = (-1)^(1) * 2^(1 - 3) * 1.1011
  // +(-0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   -1.2031250) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // (-1)^(1) * 2^(3 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0011));
}
drivenby { // case 304
  x = (true@0b001@0b0011);
  y = (true@0b001@0b0110);
  // x + y
  //   -0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // +(-0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // ----------------------------------------------
  //   -0.6406250) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // (-1)^(1) * 2^(2 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0100));
}
drivenby { // case 305
  x = (false@0b001@0b1010);
  y = (true@0b000@0b0111);
  // x + y
  //   +0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // +(-0.1093750) = (-1)^(1) * 2^(1 - 3) * 0.0111
  // ----------------------------------------------
  //   +0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // (-1)^(0) * 2^(1 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0011));
}
drivenby { // case 306
  x = (false@0b001@0b1111);
  y = (true@0b011@0b1100);
  // x + y
  //   +0.4843750) = (-1)^(0) * 2^(1 - 3) * 1.1111
  // +(-1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   -1.2656250) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 307
  x = (true@0b101@0b0001);
  y = (false@0b010@0b0011);
  // x + y
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // +(+0.5937500) = (-1)^(0) * 2^(2 - 3) * 1.0011
  // ----------------------------------------------
  //   -3.6562500) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // (-1)^(1) * 2^(4 - 3) * 11101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1101));
}
drivenby { // case 308
  x = (true@0b000@0b1010);
  y = (false@0b011@0b0100);
  // x + y
  //   -0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // +(+1.2500000) = (-1)^(0) * 2^(3 - 3) * 1.0100
  // ----------------------------------------------
  //   +1.0937500) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // (-1)^(0) * 2^(3 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0010));
}
drivenby { // case 309
  x = (true@0b011@0b1000);
  y = (true@0b100@0b1111);
  // x + y
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // +(-3.8750000) = (-1)^(1) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   -5.3750000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // (-1)^(1) * 2^(5 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0110));
}
drivenby { // case 310
  x = (true@0b010@0b0001);
  y = (false@0b011@0b0001);
  // x + y
  //   -0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // +(+1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // (-1)^(0) * 2^(2 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0001));
}
drivenby { // case 311
  x = (true@0b010@0b1100);
  y = (true@0b001@0b1101);
  // x + y
  //   -0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // +(-0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   -1.3281250) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 312
  x = (true@0b000@0b1110);
  y = (false@0b011@0b1111);
  // x + y
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // +(+1.9375000) = (-1)^(0) * 2^(3 - 3) * 1.1111
  // ----------------------------------------------
  //   +1.7187500) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // (-1)^(0) * 2^(3 - 3) * 11011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1100));
}
drivenby { // case 313
  x = (true@0b000@0b1100);
  y = (false@0b001@0b0100);
  // x + y
  //   -0.1875000) = (-1)^(1) * 2^(1 - 3) * 0.1100
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   +0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // (-1)^(0) * 2^(0 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1000));
}
drivenby { // case 314
  x = (false@0b010@0b1101);
  y = (false@0b011@0b0111);
  // x + y
  //   +0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // +(+1.4375000) = (-1)^(0) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   +2.3437500) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // (-1)^(0) * 2^(4 - 3) * 10010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0011));
}
drivenby { // case 315
  x = (false@0b011@0b1010);
  y = (true@0b001@0b0111);
  // x + y
  //   +1.6250000) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // +(-0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // ----------------------------------------------
  //   +1.2656250) = (-1)^(0) * 2^(3 - 3) * 1.0100
  // (-1)^(0) * 2^(3 - 3) * 10100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0100));
}
drivenby { // case 316
  x = (false@0b010@0b0001);
  y = (false@0b101@0b1110);
  // x + y
  //   +0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // +(+7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   +8.0312500) = (-1)^(0) * 2^(6 - 3) * 1.0000
  // (-1)^(0) * 2^(6 - 3) * 10000 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0000));
}
drivenby { // case 317
  x = (false@0b001@0b0101);
  y = (false@0b001@0b1000);
  // x + y
  //   +0.3281250) = (-1)^(0) * 2^(1 - 3) * 1.0101
  // +(+0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   +0.7031250) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // (-1)^(0) * 2^(2 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0110));
}
drivenby { // case 318
  x = (true@0b101@0b0110);
  y = (false@0b001@0b1011);
  // x + y
  //   -5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // +(+0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   -5.0781250) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // (-1)^(1) * 2^(5 - 3) * 10100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0100));
}
drivenby { // case 319
  x = (true@0b101@0b0000);
  y = (false@0b100@0b0111);
  // x + y
  //   -4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // +(+2.8750000) = (-1)^(0) * 2^(4 - 3) * 1.0111
  // ----------------------------------------------
  //   -1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // (-1)^(1) * 2^(3 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0010));
}
drivenby { // case 320
  x = (false@0b100@0b1000);
  y = (false@0b001@0b1101);
  // x + y
  //   +3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // +(+0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   +3.4531250) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // (-1)^(0) * 2^(4 - 3) * 11011 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1100));
}
drivenby { // case 321
  x = (true@0b001@0b0110);
  y = (true@0b011@0b0001);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(-1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   -1.4062500) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // (-1)^(1) * 2^(3 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0110));
}
drivenby { // case 322
  x = (true@0b011@0b1100);
  y = (false@0b000@0b1100);
  // x + y
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // +(+0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // ----------------------------------------------
  //   -1.5625000) = (-1)^(1) * 2^(3 - 3) * 1.1001
  // (-1)^(1) * 2^(3 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1001));
}
drivenby { // case 323
  x = (false@0b001@0b0111);
  y = (true@0b100@0b1110);
  // x + y
  //   +0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // +(-3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // ----------------------------------------------
  //   -3.3906250) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // (-1)^(1) * 2^(4 - 3) * 11011 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1011));
}
drivenby { // case 324
  x = (false@0b101@0b0001);
  y = (false@0b101@0b1001);
  // x + y
  //   +4.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0001
  // +(+6.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // ----------------------------------------------
  //   +10.5000000) = (-1)^(0) * 2^(6 - 3) * 1.0101
  // (-1)^(0) * 2^(6 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0101));
}
drivenby { // case 325
  x = (false@0b011@0b0101);
  y = (false@0b001@0b0110);
  // x + y
  //   +1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // +(+0.3437500) = (-1)^(0) * 2^(1 - 3) * 1.0110
  // ----------------------------------------------
  //   +1.6562500) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // (-1)^(0) * 2^(3 - 3) * 11010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1010));
}
drivenby { // case 326
  x = (false@0b101@0b1101);
  y = (false@0b010@0b0111);
  // x + y
  //   +7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // +(+0.7187500) = (-1)^(0) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   +7.9687500) = (-1)^(0) * 2^(6 - 3) * 1.0000
  // (-1)^(0) * 2^(5 - 3) * 11111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0000));
}
drivenby { // case 327
  x = (true@0b101@0b0000);
  y = (false@0b010@0b0110);
  // x + y
  //   -4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   -3.3125000) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // (-1)^(1) * 2^(4 - 3) * 11010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1010));
}
drivenby { // case 328
  x = (false@0b000@0b0100);
  y = (true@0b101@0b1110);
  // x + y
  //   +0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // +(-7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   -7.4375000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // (-1)^(1) * 2^(5 - 3) * 11101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1110));
}
drivenby { // case 329
  x = (true@0b000@0b0110);
  y = (false@0b100@0b0010);
  // x + y
  //   -0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +2.1562500) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // (-1)^(0) * 2^(4 - 3) * 10001 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0001));
}
drivenby { // case 330
  x = (false@0b010@0b0110);
  y = (true@0b001@0b0001);
  // x + y
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // +(-0.2656250) = (-1)^(1) * 2^(1 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // (-1)^(0) * 2^(1 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1011));
}
drivenby { // case 331
  x = (false@0b011@0b1100);
  y = (true@0b101@0b1000);
  // x + y
  //   +1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // +(-6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 332
  x = (false@0b100@0b0100);
  y = (true@0b100@0b0100);
  // x + y
  //   +2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // +(-2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // ----------------------------------------------
  //   +0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // (-1)^(0) * 2^(3 - 3) * 00000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0000));
}
drivenby { // case 333
  x = (true@0b010@0b0000);
  y = (true@0b101@0b0000);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(-4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   -4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 334
  x = (true@0b010@0b1110);
  y = (false@0b101@0b1010);
  // x + y
  //   -0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +5.5625000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 335
  x = (true@0b011@0b1101);
  y = (true@0b010@0b1110);
  // x + y
  //   -1.8125000) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // +(-0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 336
  x = (false@0b000@0b1101);
  y = (true@0b000@0b1101);
  // x + y
  //   +0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // +(-0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   +0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // (-1)^(0) * 2^(3 - 3) * 00000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0000));
}
drivenby { // case 337
  x = (true@0b100@0b1100);
  y = (true@0b011@0b1111);
  // x + y
  //   -3.5000000) = (-1)^(1) * 2^(4 - 3) * 1.1100
  // +(-1.9375000) = (-1)^(1) * 2^(3 - 3) * 1.1111
  // ----------------------------------------------
  //   -5.4375000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // (-1)^(1) * 2^(5 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0110));
}
drivenby { // case 338
  x = (true@0b011@0b1001);
  y = (false@0b000@0b0001);
  // x + y
  //   -1.5625000) = (-1)^(1) * 2^(3 - 3) * 1.1001
  // +(+0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   -1.5468750) = (-1)^(1) * 2^(3 - 3) * 1.1001
  // (-1)^(1) * 2^(3 - 3) * 11000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1001));
}
drivenby { // case 339
  x = (false@0b010@0b1001);
  y = (false@0b000@0b1111);
  // x + y
  //   +0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // +(+0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // ----------------------------------------------
  //   +1.0156250) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 340
  x = (false@0b001@0b1011);
  y = (true@0b010@0b0110);
  // x + y
  //   +0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // +(-0.6875000) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   -0.2656250) = (-1)^(1) * 2^(1 - 3) * 1.0001
  // (-1)^(1) * 2^(1 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0001));
}
drivenby { // case 341
  x = (true@0b001@0b0100);
  y = (false@0b100@0b0100);
  // x + y
  //   -0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // +(+2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // ----------------------------------------------
  //   +2.1875000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // (-1)^(0) * 2^(4 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0010));
}
drivenby { // case 342
  x = (false@0b101@0b1101);
  y = (true@0b101@0b1110);
  // x + y
  //   +7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // +(-7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   -0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // (-1)^(1) * 2^(1 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0000));
}
drivenby { // case 343
  x = (false@0b100@0b1111);
  y = (true@0b010@0b1000);
  // x + y
  //   +3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   +3.1250000) = (-1)^(0) * 2^(4 - 3) * 1.1001
  // (-1)^(0) * 2^(4 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1001));
}
drivenby { // case 344
  x = (false@0b000@0b0011);
  y = (false@0b010@0b0110);
  // x + y
  //   +0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   +0.7343750) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // (-1)^(0) * 2^(2 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1000));
}
drivenby { // case 345
  x = (false@0b101@0b1100);
  y = (false@0b010@0b1100);
  // x + y
  //   +7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // +(+0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   +7.8750000) = (-1)^(0) * 2^(6 - 3) * 1.0000
  // (-1)^(0) * 2^(5 - 3) * 11111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0000));
}
drivenby { // case 346
  x = (false@0b100@0b1001);
  y = (false@0b100@0b1111);
  // x + y
  //   +3.1250000) = (-1)^(0) * 2^(4 - 3) * 1.1001
  // +(+3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   +7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // (-1)^(0) * 2^(5 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1100));
}
drivenby { // case 347
  x = (true@0b001@0b0111);
  y = (false@0b100@0b0100);
  // x + y
  //   -0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // +(+2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // ----------------------------------------------
  //   +2.1406250) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // (-1)^(0) * 2^(4 - 3) * 10001 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0001));
}
drivenby { // case 348
  x = (false@0b000@0b0101);
  y = (false@0b011@0b1011);
  // x + y
  //   +0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // +(+1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   +1.7656250) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // (-1)^(0) * 2^(3 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1100));
}
drivenby { // case 349
  x = (false@0b100@0b0101);
  y = (false@0b010@0b1000);
  // x + y
  //   +2.6250000) = (-1)^(0) * 2^(4 - 3) * 1.0101
  // +(+0.7500000) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // (-1)^(0) * 2^(4 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1011));
}
drivenby { // case 350
  x = (false@0b000@0b0110);
  y = (false@0b000@0b0000);
  // x + y
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // +(+0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // (-1)^(0) * 2^(-1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0110));
}
drivenby { // case 351
  x = (true@0b100@0b0011);
  y = (false@0b101@0b1110);
  // x + y
  //   -2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // +(+7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   +5.1250000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 352
  x = (false@0b000@0b1101);
  y = (true@0b100@0b0111);
  // x + y
  //   +0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // +(-2.8750000) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // ----------------------------------------------
  //   -2.6718750) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // (-1)^(1) * 2^(4 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0101));
}
drivenby { // case 353
  x = (true@0b010@0b0001);
  y = (true@0b100@0b0010);
  // x + y
  //   -0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // +(-2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   -2.7812500) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 354
  x = (false@0b010@0b1110);
  y = (false@0b010@0b1110);
  // x + y
  //   +0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // +(+0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   +1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // (-1)^(0) * 2^(3 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1110));
}
drivenby { // case 355
  x = (false@0b101@0b0001);
  y = (true@0b101@0b0001);
  // x + y
  //   +4.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0001
  // +(-4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // (-1)^(0) * 2^(3 - 3) * 00000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0000));
}
drivenby { // case 356
  x = (false@0b100@0b0110);
  y = (false@0b011@0b0011);
  // x + y
  //   +2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // +(+1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   +3.9375000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // (-1)^(0) * 2^(4 - 3) * 11111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0000));
}
drivenby { // case 357
  x = (false@0b001@0b1101);
  y = (true@0b000@0b0000);
  // x + y
  //   +0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // +(-0.0000000) = (-1)^(1) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   +0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // (-1)^(0) * 2^(1 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1101));
}
drivenby { // case 358
  x = (false@0b011@0b1101);
  y = (true@0b100@0b0010);
  // x + y
  //   +1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // +(-2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   -0.4375000) = (-1)^(1) * 2^(1 - 3) * 1.1100
  // (-1)^(1) * 2^(1 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1100));
}
drivenby { // case 359
  x = (true@0b001@0b0110);
  y = (false@0b001@0b0001);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(+0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // ----------------------------------------------
  //   -0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // (-1)^(1) * 2^(-1 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0101));
}
drivenby { // case 360
  x = (false@0b101@0b1000);
  y = (true@0b100@0b0111);
  // x + y
  //   +6.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // +(-2.8750000) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // ----------------------------------------------
  //   +3.1250000) = (-1)^(0) * 2^(4 - 3) * 1.1001
  // (-1)^(0) * 2^(4 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1001));
}
drivenby { // case 361
  x = (true@0b010@0b1100);
  y = (true@0b000@0b0111);
  // x + y
  //   -0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // +(-0.1093750) = (-1)^(1) * 2^(1 - 3) * 0.0111
  // ----------------------------------------------
  //   -0.9843750) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // (-1)^(1) * 2^(2 - 3) * 11111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0000));
}
drivenby { // case 362
  x = (false@0b000@0b1000);
  y = (true@0b011@0b0110);
  // x + y
  //   +0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // +(-1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 363
  x = (false@0b001@0b0101);
  y = (true@0b000@0b1011);
  // x + y
  //   +0.3281250) = (-1)^(0) * 2^(1 - 3) * 1.0101
  // +(-0.1718750) = (-1)^(1) * 2^(1 - 3) * 0.1011
  // ----------------------------------------------
  //   +0.1562500) = (-1)^(0) * 2^(1 - 3) * 0.1010
  // (-1)^(0) * 2^(0 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1010));
}
drivenby { // case 364
  x = (true@0b010@0b1000);
  y = (false@0b010@0b1101);
  // x + y
  //   -0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // +(+0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // ----------------------------------------------
  //   +0.1562500) = (-1)^(0) * 2^(1 - 3) * 0.1010
  // (-1)^(0) * 2^(0 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1010));
}
drivenby { // case 365
  x = (true@0b000@0b1111);
  y = (true@0b000@0b0100);
  // x + y
  //   -0.2343750) = (-1)^(1) * 2^(1 - 3) * 0.1111
  // +(-0.0625000) = (-1)^(1) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   -0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // (-1)^(1) * 2^(1 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0011));
}
drivenby { // case 366
  x = (false@0b101@0b1101);
  y = (false@0b100@0b1111);
  // x + y
  //   +7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // +(+3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   +11.1250000) = (-1)^(0) * 2^(6 - 3) * 1.0110
  // (-1)^(0) * 2^(6 - 3) * 10110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0110));
}
drivenby { // case 367
  x = (true@0b000@0b1111);
  y = (true@0b001@0b0011);
  // x + y
  //   -0.2343750) = (-1)^(1) * 2^(1 - 3) * 0.1111
  // +(-0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // ----------------------------------------------
  //   -0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // (-1)^(1) * 2^(2 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0001));
}
drivenby { // case 368
  x = (true@0b001@0b0111);
  y = (false@0b000@0b1100);
  // x + y
  //   -0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // +(+0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // ----------------------------------------------
  //   -0.1718750) = (-1)^(1) * 2^(1 - 3) * 0.1011
  // (-1)^(1) * 2^(0 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1011));
}
drivenby { // case 369
  x = (false@0b100@0b1101);
  y = (false@0b100@0b0001);
  // x + y
  //   +3.6250000) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // +(+2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // ----------------------------------------------
  //   +5.7500000) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // (-1)^(0) * 2^(5 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0111));
}
drivenby { // case 370
  x = (false@0b101@0b0100);
  y = (false@0b000@0b0011);
  // x + y
  //   +5.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // +(+0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // ----------------------------------------------
  //   +5.0468750) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 371
  x = (true@0b010@0b1001);
  y = (false@0b101@0b0011);
  // x + y
  //   -0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // +(+4.7500000) = (-1)^(0) * 2^(5 - 3) * 1.0011
  // ----------------------------------------------
  //   +3.9687500) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // (-1)^(0) * 2^(4 - 3) * 11111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0000));
}
drivenby { // case 372
  x = (true@0b100@0b0111);
  y = (true@0b100@0b0010);
  // x + y
  //   -2.8750000) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // +(-2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   -5.1250000) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // (-1)^(1) * 2^(5 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0100));
}
drivenby { // case 373
  x = (true@0b101@0b0101);
  y = (false@0b000@0b1110);
  // x + y
  //   -5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // +(+0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // ----------------------------------------------
  //   -5.0312500) = (-1)^(1) * 2^(5 - 3) * 1.0100
  // (-1)^(1) * 2^(5 - 3) * 10100 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0100));
}
drivenby { // case 374
  x = (true@0b010@0b1101);
  y = (true@0b100@0b1011);
  // x + y
  //   -0.9062500) = (-1)^(1) * 2^(2 - 3) * 1.1101
  // +(-3.3750000) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   -4.2812500) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10001 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 375
  x = (false@0b100@0b1000);
  y = (false@0b001@0b1100);
  // x + y
  //   +3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // +(+0.4375000) = (-1)^(0) * 2^(1 - 3) * 1.1100
  // ----------------------------------------------
  //   +3.4375000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // (-1)^(0) * 2^(4 - 3) * 11011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1100));
}
drivenby { // case 376
  x = (false@0b010@0b1111);
  y = (true@0b100@0b1100);
  // x + y
  //   +0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // +(-3.5000000) = (-1)^(1) * 2^(4 - 3) * 1.1100
  // ----------------------------------------------
  //   -2.5312500) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 377
  x = (false@0b011@0b0010);
  y = (true@0b001@0b0010);
  // x + y
  //   +1.1250000) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // +(-0.2812500) = (-1)^(1) * 2^(1 - 3) * 1.0010
  // ----------------------------------------------
  //   +0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // (-1)^(0) * 2^(2 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1011));
}
drivenby { // case 378
  x = (true@0b010@0b0010);
  y = (false@0b010@0b0110);
  // x + y
  //   -0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   +0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // (-1)^(0) * 2^(0 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1000));
}
drivenby { // case 379
  x = (false@0b101@0b0110);
  y = (true@0b000@0b1101);
  // x + y
  //   +5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // +(-0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   +5.2968750) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // (-1)^(0) * 2^(5 - 3) * 10101 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0101));
}
drivenby { // case 380
  x = (true@0b011@0b0001);
  y = (true@0b011@0b1000);
  // x + y
  //   -1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // +(-1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   -2.5625000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 381
  x = (false@0b100@0b1000);
  y = (true@0b101@0b1110);
  // x + y
  //   +3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // +(-7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   -4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 382
  x = (true@0b000@0b1100);
  y = (true@0b001@0b1000);
  // x + y
  //   -0.1875000) = (-1)^(1) * 2^(1 - 3) * 0.1100
  // +(-0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   -0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // (-1)^(1) * 2^(2 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0010));
}
drivenby { // case 383
  x = (false@0b001@0b1110);
  y = (false@0b101@0b0010);
  // x + y
  //   +0.4687500) = (-1)^(0) * 2^(1 - 3) * 1.1110
  // +(+4.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // ----------------------------------------------
  //   +4.9687500) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 384
  x = (false@0b001@0b1110);
  y = (false@0b011@0b1110);
  // x + y
  //   +0.4687500) = (-1)^(0) * 2^(1 - 3) * 1.1110
  // +(+1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // ----------------------------------------------
  //   +2.3437500) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // (-1)^(0) * 2^(4 - 3) * 10010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0011));
}
drivenby { // case 385
  x = (false@0b010@0b0101);
  y = (true@0b011@0b0111);
  // x + y
  //   +0.6562500) = (-1)^(0) * 2^(2 - 3) * 1.0101
  // +(-1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   -0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // (-1)^(1) * 2^(2 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1001));
}
drivenby { // case 386
  x = (true@0b001@0b1001);
  y = (true@0b100@0b0100);
  // x + y
  //   -0.3906250) = (-1)^(1) * 2^(1 - 3) * 1.1001
  // +(-2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // ----------------------------------------------
  //   -2.8906250) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // (-1)^(1) * 2^(4 - 3) * 10111 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0111));
}
drivenby { // case 387
  x = (true@0b001@0b1100);
  y = (true@0b011@0b1000);
  // x + y
  //   -0.4375000) = (-1)^(1) * 2^(1 - 3) * 1.1100
  // +(-1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   -1.9375000) = (-1)^(1) * 2^(3 - 3) * 1.1111
  // (-1)^(1) * 2^(3 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1111));
}
drivenby { // case 388
  x = (true@0b101@0b1001);
  y = (false@0b001@0b0100);
  // x + y
  //   -6.2500000) = (-1)^(1) * 2^(5 - 3) * 1.1001
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   -5.9375000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // (-1)^(1) * 2^(5 - 3) * 10111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1000));
}
drivenby { // case 389
  x = (false@0b011@0b1000);
  y = (false@0b011@0b0001);
  // x + y
  //   +1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // +(+1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   +2.5625000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // (-1)^(0) * 2^(4 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0100));
}
drivenby { // case 390
  x = (true@0b001@0b1011);
  y = (false@0b011@0b1110);
  // x + y
  //   -0.4218750) = (-1)^(1) * 2^(1 - 3) * 1.1011
  // +(+1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // ----------------------------------------------
  //   +1.4531250) = (-1)^(0) * 2^(3 - 3) * 1.0111
  // (-1)^(0) * 2^(3 - 3) * 10111 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0111));
}
drivenby { // case 391
  x = (true@0b010@0b1000);
  y = (false@0b000@0b0011);
  // x + y
  //   -0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // +(+0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // ----------------------------------------------
  //   -0.7031250) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // (-1)^(1) * 2^(2 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0110));
}
drivenby { // case 392
  x = (true@0b001@0b0110);
  y = (true@0b100@0b1001);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(-3.1250000) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // ----------------------------------------------
  //   -3.4687500) = (-1)^(1) * 2^(4 - 3) * 1.1100
  // (-1)^(1) * 2^(4 - 3) * 11011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1100));
}
drivenby { // case 393
  x = (true@0b010@0b0010);
  y = (false@0b010@0b0011);
  // x + y
  //   -0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // +(+0.5937500) = (-1)^(0) * 2^(2 - 3) * 1.0011
  // ----------------------------------------------
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // (-1)^(0) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0010));
}
drivenby { // case 394
  x = (true@0b000@0b0001);
  y = (true@0b001@0b0101);
  // x + y
  //   -0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // +(-0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // ----------------------------------------------
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // (-1)^(1) * 2^(1 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0110));
}
drivenby { // case 395
  x = (false@0b010@0b0110);
  y = (true@0b010@0b0111);
  // x + y
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // +(-0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   -0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // (-1)^(1) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0010));
}
drivenby { // case 396
  x = (true@0b100@0b0000);
  y = (true@0b010@0b1000);
  // x + y
  //   -2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 397
  x = (false@0b011@0b1101);
  y = (false@0b101@0b1010);
  // x + y
  //   +1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +8.3125000) = (-1)^(0) * 2^(6 - 3) * 1.0001
  // (-1)^(0) * 2^(6 - 3) * 10000 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0001));
}
drivenby { // case 398
  x = (true@0b010@0b0110);
  y = (true@0b001@0b0000);
  // x + y
  //   -0.6875000) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // (-1)^(1) * 2^(2 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1110));
}
drivenby { // case 399
  x = (false@0b000@0b0101);
  y = (false@0b101@0b0011);
  // x + y
  //   +0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // +(+4.7500000) = (-1)^(0) * 2^(5 - 3) * 1.0011
  // ----------------------------------------------
  //   +4.8281250) = (-1)^(0) * 2^(5 - 3) * 1.0011
  // (-1)^(0) * 2^(5 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0011));
}
drivenby { // case 400
  x = (true@0b001@0b1001);
  y = (true@0b010@0b0010);
  // x + y
  //   -0.3906250) = (-1)^(1) * 2^(1 - 3) * 1.1001
  // +(-0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // ----------------------------------------------
  //   -0.9531250) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // (-1)^(1) * 2^(2 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1110));
}
drivenby { // case 401
  x = (true@0b001@0b0100);
  y = (true@0b011@0b1000);
  // x + y
  //   -0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // +(-1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   -1.8125000) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // (-1)^(1) * 2^(3 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1101));
}
drivenby { // case 402
  x = (true@0b011@0b0100);
  y = (false@0b011@0b0011);
  // x + y
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // +(+1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   -0.0625000) = (-1)^(1) * 2^(1 - 3) * 0.0100
  // (-1)^(1) * 2^(-1 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0100));
}
drivenby { // case 403
  x = (false@0b000@0b1110);
  y = (false@0b011@0b1100);
  // x + y
  //   +0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // +(+1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   +1.9687500) = (-1)^(0) * 2^(4 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 11111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0000));
}
drivenby { // case 404
  x = (false@0b001@0b0100);
  y = (true@0b011@0b1101);
  // x + y
  //   +0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // +(-1.8125000) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // ----------------------------------------------
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // (-1)^(1) * 2^(3 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1000));
}
drivenby { // case 405
  x = (false@0b100@0b1000);
  y = (false@0b101@0b0000);
  // x + y
  //   +3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // +(+4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   +7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // (-1)^(0) * 2^(5 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1100));
}
drivenby { // case 406
  x = (false@0b100@0b0100);
  y = (false@0b001@0b1011);
  // x + y
  //   +2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // +(+0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   +2.9218750) = (-1)^(0) * 2^(4 - 3) * 1.0111
  // (-1)^(0) * 2^(4 - 3) * 10111 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0111));
}
drivenby { // case 407
  x = (false@0b010@0b1100);
  y = (false@0b011@0b1101);
  // x + y
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // +(+1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // ----------------------------------------------
  //   +2.6875000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // (-1)^(0) * 2^(4 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0110));
}
drivenby { // case 408
  x = (true@0b001@0b0111);
  y = (true@0b010@0b1100);
  // x + y
  //   -0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // +(-0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   -1.2343750) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 409
  x = (true@0b100@0b1111);
  y = (false@0b011@0b0010);
  // x + y
  //   -3.8750000) = (-1)^(1) * 2^(4 - 3) * 1.1111
  // +(+1.1250000) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // ----------------------------------------------
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 410
  x = (true@0b000@0b0101);
  y = (false@0b100@0b1101);
  // x + y
  //   -0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // +(+3.6250000) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // ----------------------------------------------
  //   +3.5468750) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // (-1)^(0) * 2^(4 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1100));
}
drivenby { // case 411
  x = (false@0b010@0b0100);
  y = (false@0b010@0b1101);
  // x + y
  //   +0.6250000) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // +(+0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // ----------------------------------------------
  //   +1.5312500) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // (-1)^(0) * 2^(3 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1000));
}
drivenby { // case 412
  x = (true@0b100@0b0010);
  y = (true@0b001@0b1111);
  // x + y
  //   -2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // +(-0.4843750) = (-1)^(1) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   -2.7343750) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 413
  x = (false@0b010@0b1110);
  y = (true@0b101@0b0110);
  // x + y
  //   +0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // +(-5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   -4.5625000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 414
  x = (true@0b001@0b0111);
  y = (false@0b101@0b1010);
  // x + y
  //   -0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +6.1406250) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // (-1)^(0) * 2^(5 - 3) * 11000 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1001));
}
drivenby { // case 415
  x = (false@0b000@0b0010);
  y = (false@0b010@0b1110);
  // x + y
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // +(+0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   +0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // (-1)^(0) * 2^(2 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1111));
}
drivenby { // case 416
  x = (false@0b001@0b1010);
  y = (false@0b001@0b1100);
  // x + y
  //   +0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // +(+0.4375000) = (-1)^(0) * 2^(1 - 3) * 1.1100
  // ----------------------------------------------
  //   +0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // (-1)^(0) * 2^(2 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1011));
}
drivenby { // case 417
  x = (true@0b011@0b1101);
  y = (true@0b100@0b0000);
  // x + y
  //   -1.8125000) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // +(-2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // ----------------------------------------------
  //   -3.8125000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // (-1)^(1) * 2^(4 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1110));
}
drivenby { // case 418
  x = (false@0b001@0b1000);
  y = (true@0b000@0b1010);
  // x + y
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // +(-0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // ----------------------------------------------
  //   +0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // (-1)^(0) * 2^(0 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1110));
}
drivenby { // case 419
  x = (true@0b000@0b0111);
  y = (false@0b000@0b1111);
  // x + y
  //   -0.1093750) = (-1)^(1) * 2^(1 - 3) * 0.0111
  // +(+0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // ----------------------------------------------
  //   +0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // (-1)^(0) * 2^(0 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1000));
}
drivenby { // case 420
  x = (true@0b001@0b1110);
  y = (true@0b001@0b1001);
  // x + y
  //   -0.4687500) = (-1)^(1) * 2^(1 - 3) * 1.1110
  // +(-0.3906250) = (-1)^(1) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   -0.8593750) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // (-1)^(1) * 2^(2 - 3) * 11011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1100));
}
drivenby { // case 421
  x = (false@0b101@0b1110);
  y = (false@0b101@0b0001);
  // x + y
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // +(+4.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0001
  // ----------------------------------------------
  //   +11.7500000) = (-1)^(0) * 2^(6 - 3) * 1.1000
  // (-1)^(0) * 2^(6 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b1000));
}
drivenby { // case 422
  x = (true@0b001@0b1110);
  y = (false@0b010@0b0001);
  // x + y
  //   -0.4687500) = (-1)^(1) * 2^(1 - 3) * 1.1110
  // +(+0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // (-1)^(0) * 2^(-1 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0100));
}
drivenby { // case 423
  x = (false@0b011@0b0110);
  y = (false@0b010@0b0100);
  // x + y
  //   +1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // +(+0.6250000) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // ----------------------------------------------
  //   +2.0000000) = (-1)^(0) * 2^(4 - 3) * 1.0000
  // (-1)^(0) * 2^(4 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0000));
}
drivenby { // case 424
  x = (false@0b011@0b1000);
  y = (true@0b010@0b0001);
  // x + y
  //   +1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // +(-0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   +0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // (-1)^(0) * 2^(2 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1111));
}
drivenby { // case 425
  x = (true@0b011@0b0000);
  y = (false@0b010@0b1111);
  // x + y
  //   -1.0000000) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // +(+0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   -0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // (-1)^(1) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0010));
}
drivenby { // case 426
  x = (true@0b100@0b1101);
  y = (true@0b101@0b1100);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(-7.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // ----------------------------------------------
  //   -10.6250000) = (-1)^(1) * 2^(6 - 3) * 1.0101
  // (-1)^(1) * 2^(6 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0101));
}
drivenby { // case 427
  x = (false@0b100@0b1011);
  y = (true@0b000@0b0110);
  // x + y
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // +(-0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // ----------------------------------------------
  //   +3.2812500) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // (-1)^(0) * 2^(4 - 3) * 11010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1010));
}
drivenby { // case 428
  x = (false@0b000@0b0110);
  y = (false@0b010@0b1101);
  // x + y
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // +(+0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // ----------------------------------------------
  //   +1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 429
  x = (false@0b101@0b0010);
  y = (true@0b010@0b0100);
  // x + y
  //   +4.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // +(-0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // ----------------------------------------------
  //   +3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // (-1)^(0) * 2^(4 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1111));
}
drivenby { // case 430
  x = (false@0b100@0b1101);
  y = (false@0b000@0b0001);
  // x + y
  //   +3.6250000) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // +(+0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   +3.6406250) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // (-1)^(0) * 2^(4 - 3) * 11101 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1101));
}
drivenby { // case 431
  x = (true@0b001@0b0000);
  y = (false@0b010@0b0011);
  // x + y
  //   -0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // +(+0.5937500) = (-1)^(0) * 2^(2 - 3) * 1.0011
  // ----------------------------------------------
  //   +0.3437500) = (-1)^(0) * 2^(1 - 3) * 1.0110
  // (-1)^(0) * 2^(1 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0110));
}
drivenby { // case 432
  x = (true@0b010@0b0111);
  y = (false@0b001@0b1001);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(+0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   -0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // (-1)^(1) * 2^(1 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0101));
}
drivenby { // case 433
  x = (false@0b001@0b1001);
  y = (true@0b101@0b0000);
  // x + y
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // +(-4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   -3.6093750) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // (-1)^(1) * 2^(4 - 3) * 11100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1101));
}
drivenby { // case 434
  x = (false@0b000@0b0000);
  y = (true@0b001@0b1011);
  // x + y
  //   +0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // +(-0.4218750) = (-1)^(1) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   -0.4218750) = (-1)^(1) * 2^(1 - 3) * 1.1011
  // (-1)^(1) * 2^(1 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1011));
}
drivenby { // case 435
  x = (true@0b001@0b1101);
  y = (true@0b011@0b0101);
  // x + y
  //   -0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // +(-1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // ----------------------------------------------
  //   -1.7656250) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // (-1)^(1) * 2^(3 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1100));
}
drivenby { // case 436
  x = (true@0b100@0b1100);
  y = (true@0b001@0b0000);
  // x + y
  //   -3.5000000) = (-1)^(1) * 2^(4 - 3) * 1.1100
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // (-1)^(1) * 2^(4 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1110));
}
drivenby { // case 437
  x = (true@0b000@0b1001);
  y = (false@0b100@0b0010);
  // x + y
  //   -0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +2.1093750) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // (-1)^(0) * 2^(4 - 3) * 10000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0001));
}
drivenby { // case 438
  x = (false@0b011@0b0000);
  y = (true@0b100@0b0001);
  // x + y
  //   +1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // +(-2.1250000) = (-1)^(1) * 2^(4 - 3) * 1.0001
  // ----------------------------------------------
  //   -1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // (-1)^(1) * 2^(3 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0010));
}
drivenby { // case 439
  x = (true@0b011@0b1011);
  y = (false@0b010@0b0110);
  // x + y
  //   -1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   -1.0000000) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // (-1)^(1) * 2^(3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0000));
}
drivenby { // case 440
  x = (false@0b001@0b0011);
  y = (true@0b100@0b0010);
  // x + y
  //   +0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // +(-2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   -1.9531250) = (-1)^(1) * 2^(3 - 3) * 1.1111
  // (-1)^(1) * 2^(3 - 3) * 11111 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1111));
}
drivenby { // case 441
  x = (true@0b001@0b0011);
  y = (true@0b101@0b0010);
  // x + y
  //   -0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // +(-4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // ----------------------------------------------
  //   -4.7968750) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // (-1)^(1) * 2^(5 - 3) * 10011 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0011));
}
drivenby { // case 442
  x = (false@0b100@0b1100);
  y = (true@0b000@0b0110);
  // x + y
  //   +3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // +(-0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // ----------------------------------------------
  //   +3.4062500) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // (-1)^(0) * 2^(4 - 3) * 11011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1011));
}
drivenby { // case 443
  x = (true@0b000@0b1111);
  y = (true@0b100@0b0010);
  // x + y
  //   -0.2343750) = (-1)^(1) * 2^(1 - 3) * 0.1111
  // +(-2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   -2.4843750) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 444
  x = (true@0b011@0b0001);
  y = (false@0b100@0b1111);
  // x + y
  //   -1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // +(+3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   +2.8125000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // (-1)^(0) * 2^(4 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0110));
}
drivenby { // case 445
  x = (true@0b100@0b0000);
  y = (false@0b011@0b0011);
  // x + y
  //   -2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // +(+1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   -0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // (-1)^(1) * 2^(2 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1010));
}
drivenby { // case 446
  x = (true@0b100@0b1000);
  y = (false@0b010@0b0001);
  // x + y
  //   -3.0000000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // +(+0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   -2.4687500) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 447
  x = (false@0b010@0b0001);
  y = (false@0b011@0b0000);
  // x + y
  //   +0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // +(+1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // ----------------------------------------------
  //   +1.5312500) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // (-1)^(0) * 2^(3 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1000));
}
drivenby { // case 448
  x = (false@0b000@0b0011);
  y = (false@0b100@0b1110);
  // x + y
  //   +0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // +(+3.7500000) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // ----------------------------------------------
  //   +3.7968750) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // (-1)^(0) * 2^(4 - 3) * 11110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1110));
}
drivenby { // case 449
  x = (false@0b001@0b1000);
  y = (true@0b011@0b0100);
  // x + y
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // +(-1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // ----------------------------------------------
  //   -0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // (-1)^(1) * 2^(2 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1100));
}
drivenby { // case 450
  x = (false@0b010@0b1110);
  y = (false@0b011@0b0011);
  // x + y
  //   +0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // +(+1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   +2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // (-1)^(0) * 2^(4 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0001));
}
drivenby { // case 451
  x = (true@0b000@0b1101);
  y = (false@0b100@0b1110);
  // x + y
  //   -0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // +(+3.7500000) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // ----------------------------------------------
  //   +3.5468750) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // (-1)^(0) * 2^(4 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1100));
}
drivenby { // case 452
  x = (true@0b010@0b0000);
  y = (true@0b100@0b0011);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(-2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // ----------------------------------------------
  //   -2.8750000) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // (-1)^(1) * 2^(4 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0111));
}
drivenby { // case 453
  x = (true@0b100@0b1001);
  y = (true@0b100@0b0011);
  // x + y
  //   -3.1250000) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // +(-2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // ----------------------------------------------
  //   -5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // (-1)^(1) * 2^(5 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0110));
}
drivenby { // case 454
  x = (false@0b000@0b0001);
  y = (false@0b001@0b0010);
  // x + y
  //   +0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // +(+0.2812500) = (-1)^(0) * 2^(1 - 3) * 1.0010
  // ----------------------------------------------
  //   +0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // (-1)^(0) * 2^(1 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0011));
}
drivenby { // case 455
  x = (false@0b101@0b1000);
  y = (false@0b100@0b1001);
  // x + y
  //   +6.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // +(+3.1250000) = (-1)^(0) * 2^(4 - 3) * 1.1001
  // ----------------------------------------------
  //   +9.1250000) = (-1)^(0) * 2^(6 - 3) * 1.0010
  // (-1)^(0) * 2^(6 - 3) * 10010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0010));
}
drivenby { // case 456
  x = (true@0b011@0b0111);
  y = (true@0b001@0b0101);
  // x + y
  //   -1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // +(-0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // ----------------------------------------------
  //   -1.7656250) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // (-1)^(1) * 2^(3 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1100));
}
drivenby { // case 457
  x = (true@0b001@0b0101);
  y = (true@0b100@0b0011);
  // x + y
  //   -0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // +(-2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // ----------------------------------------------
  //   -2.7031250) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10101 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 458
  x = (false@0b011@0b1100);
  y = (false@0b010@0b1110);
  // x + y
  //   +1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // +(+0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   +2.6875000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // (-1)^(0) * 2^(4 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0110));
}
drivenby { // case 459
  x = (true@0b000@0b0110);
  y = (false@0b000@0b0100);
  // x + y
  //   -0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // +(+0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   -0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // (-1)^(1) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0010));
}
drivenby { // case 460
  x = (false@0b000@0b0000);
  y = (false@0b100@0b0100);
  // x + y
  //   +0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // +(+2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // ----------------------------------------------
  //   +2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // (-1)^(0) * 2^(4 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0100));
}
drivenby { // case 461
  x = (false@0b000@0b1011);
  y = (true@0b011@0b0011);
  // x + y
  //   +0.1718750) = (-1)^(0) * 2^(1 - 3) * 0.1011
  // +(-1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   -1.0156250) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // (-1)^(1) * 2^(3 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0000));
}
drivenby { // case 462
  x = (true@0b101@0b1000);
  y = (false@0b100@0b1000);
  // x + y
  //   -6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // +(+3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // ----------------------------------------------
  //   -3.0000000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // (-1)^(1) * 2^(4 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1000));
}
drivenby { // case 463
  x = (false@0b011@0b0011);
  y = (false@0b001@0b1111);
  // x + y
  //   +1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // +(+0.4843750) = (-1)^(0) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   +1.6718750) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // (-1)^(0) * 2^(3 - 3) * 11010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1011));
}
drivenby { // case 464
  x = (false@0b010@0b1100);
  y = (true@0b000@0b1000);
  // x + y
  //   +0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // +(-0.1250000) = (-1)^(1) * 2^(1 - 3) * 0.1000
  // ----------------------------------------------
  //   +0.7500000) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // (-1)^(0) * 2^(2 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1000));
}
drivenby { // case 465
  x = (false@0b010@0b0001);
  y = (false@0b001@0b1011);
  // x + y
  //   +0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // +(+0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.9531250) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // (-1)^(0) * 2^(2 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1110));
}
drivenby { // case 466
  x = (false@0b001@0b0011);
  y = (true@0b000@0b0001);
  // x + y
  //   +0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // +(-0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   +0.2812500) = (-1)^(0) * 2^(1 - 3) * 1.0010
  // (-1)^(0) * 2^(1 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0010));
}
drivenby { // case 467
  x = (false@0b011@0b1000);
  y = (false@0b100@0b0010);
  // x + y
  //   +1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +3.7500000) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // (-1)^(0) * 2^(4 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1110));
}
drivenby { // case 468
  x = (false@0b000@0b0010);
  y = (true@0b000@0b0101);
  // x + y
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // +(-0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   -0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // (-1)^(1) * 2^(-2 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0011));
}
drivenby { // case 469
  x = (true@0b100@0b0101);
  y = (true@0b010@0b0111);
  // x + y
  //   -2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // +(-0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   -3.3437500) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // (-1)^(1) * 2^(4 - 3) * 11010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1011));
}
drivenby { // case 470
  x = (true@0b010@0b0100);
  y = (false@0b100@0b0011);
  // x + y
  //   -0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // +(+2.3750000) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // ----------------------------------------------
  //   +1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // (-1)^(0) * 2^(3 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1100));
}
drivenby { // case 471
  x = (false@0b000@0b0111);
  y = (true@0b011@0b1100);
  // x + y
  //   +0.1093750) = (-1)^(0) * 2^(1 - 3) * 0.0111
  // +(-1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   -1.6406250) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // (-1)^(1) * 2^(3 - 3) * 11010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1010));
}
drivenby { // case 472
  x = (false@0b100@0b0100);
  y = (false@0b000@0b0101);
  // x + y
  //   +2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // +(+0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   +2.5781250) = (-1)^(0) * 2^(4 - 3) * 1.0101
  // (-1)^(0) * 2^(4 - 3) * 10100 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0101));
}
drivenby { // case 473
  x = (true@0b001@0b0010);
  y = (false@0b010@0b1000);
  // x + y
  //   -0.2812500) = (-1)^(1) * 2^(1 - 3) * 1.0010
  // +(+0.7500000) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   +0.4687500) = (-1)^(0) * 2^(1 - 3) * 1.1110
  // (-1)^(0) * 2^(1 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1110));
}
drivenby { // case 474
  x = (true@0b011@0b1010);
  y = (false@0b100@0b0110);
  // x + y
  //   -1.6250000) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // +(+2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // ----------------------------------------------
  //   +1.1250000) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // (-1)^(0) * 2^(3 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0010));
}
drivenby { // case 475
  x = (true@0b010@0b0100);
  y = (true@0b000@0b1010);
  // x + y
  //   -0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // +(-0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // ----------------------------------------------
  //   -0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // (-1)^(1) * 2^(2 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1001));
}
drivenby { // case 476
  x = (false@0b010@0b1010);
  y = (false@0b010@0b1110);
  // x + y
  //   +0.8125000) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // +(+0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   +1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // (-1)^(0) * 2^(3 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1100));
}
drivenby { // case 477
  x = (true@0b000@0b0001);
  y = (true@0b101@0b1110);
  // x + y
  //   -0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // +(-7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   -7.5156250) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // (-1)^(1) * 2^(5 - 3) * 11110 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1110));
}
drivenby { // case 478
  x = (true@0b010@0b1011);
  y = (true@0b000@0b1110);
  // x + y
  //   -0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // +(-0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // ----------------------------------------------
  //   -1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // (-1)^(1) * 2^(3 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0001));
}
drivenby { // case 479
  x = (true@0b101@0b1111);
  y = (true@0b011@0b0010);
  // x + y
  //   -7.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1111
  // +(-1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // ----------------------------------------------
  //   -8.8750000) = (-1)^(1) * 2^(6 - 3) * 1.0010
  // (-1)^(1) * 2^(6 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0010));
}
drivenby { // case 480
  x = (false@0b101@0b0100);
  y = (false@0b010@0b0110);
  // x + y
  //   +5.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   +5.6875000) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // (-1)^(0) * 2^(5 - 3) * 10110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0111));
}
drivenby { // case 481
  x = (true@0b011@0b0101);
  y = (true@0b101@0b0011);
  // x + y
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // +(-4.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // ----------------------------------------------
  //   -6.0625000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // (-1)^(1) * 2^(5 - 3) * 11000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1000));
}
drivenby { // case 482
  x = (true@0b100@0b0011);
  y = (true@0b001@0b1110);
  // x + y
  //   -2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // +(-0.4687500) = (-1)^(1) * 2^(1 - 3) * 1.1110
  // ----------------------------------------------
  //   -2.8437500) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // (-1)^(1) * 2^(4 - 3) * 10110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0111));
}
drivenby { // case 483
  x = (false@0b100@0b0110);
  y = (true@0b011@0b0001);
  // x + y
  //   +2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // +(-1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   +1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // (-1)^(0) * 2^(3 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1011));
}
drivenby { // case 484
  x = (true@0b010@0b1000);
  y = (true@0b010@0b0010);
  // x + y
  //   -0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // +(-0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // ----------------------------------------------
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 485
  x = (true@0b100@0b0101);
  y = (true@0b100@0b0101);
  // x + y
  //   -2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // +(-2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // ----------------------------------------------
  //   -5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // (-1)^(1) * 2^(5 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0101));
}
drivenby { // case 486
  x = (true@0b001@0b0110);
  y = (false@0b101@0b0110);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(+5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   +5.1562500) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // (-1)^(0) * 2^(5 - 3) * 10100 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0101));
}
drivenby { // case 487
  x = (true@0b000@0b0000);
  y = (true@0b100@0b1010);
  // x + y
  //   -0.0000000) = (-1)^(1) * 2^(1 - 3) * 0.0000
  // +(-3.2500000) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // ----------------------------------------------
  //   -3.2500000) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // (-1)^(1) * 2^(4 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1010));
}
drivenby { // case 488
  x = (true@0b000@0b1110);
  y = (false@0b101@0b1010);
  // x + y
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +6.2812500) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // (-1)^(0) * 2^(5 - 3) * 11001 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1001));
}
drivenby { // case 489
  x = (true@0b001@0b1010);
  y = (true@0b010@0b1000);
  // x + y
  //   -0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   -1.1562500) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // (-1)^(1) * 2^(3 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0010));
}
drivenby { // case 490
  x = (true@0b001@0b1010);
  y = (false@0b100@0b0101);
  // x + y
  //   -0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // +(+2.6250000) = (-1)^(0) * 2^(4 - 3) * 1.0101
  // ----------------------------------------------
  //   +2.2187500) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // (-1)^(0) * 2^(4 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0010));
}
drivenby { // case 491
  x = (false@0b101@0b1100);
  y = (false@0b100@0b1011);
  // x + y
  //   +7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // +(+3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   +10.3750000) = (-1)^(0) * 2^(6 - 3) * 1.0101
  // (-1)^(0) * 2^(6 - 3) * 10100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0101));
}
drivenby { // case 492
  x = (false@0b101@0b0000);
  y = (true@0b000@0b1110);
  // x + y
  //   +4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // +(-0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // ----------------------------------------------
  //   +3.7812500) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // (-1)^(0) * 2^(4 - 3) * 11110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1110));
}
drivenby { // case 493
  x = (true@0b100@0b1110);
  y = (true@0b010@0b0001);
  // x + y
  //   -3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // +(-0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   -4.2812500) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10001 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 494
  x = (true@0b001@0b0010);
  y = (false@0b100@0b0000);
  // x + y
  //   -0.2812500) = (-1)^(1) * 2^(1 - 3) * 1.0010
  // +(+2.0000000) = (-1)^(0) * 2^(4 - 3) * 1.0000
  // ----------------------------------------------
  //   +1.7187500) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // (-1)^(0) * 2^(3 - 3) * 11011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1100));
}
drivenby { // case 495
  x = (false@0b000@0b0110);
  y = (true@0b000@0b1110);
  // x + y
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // +(-0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // ----------------------------------------------
  //   -0.1250000) = (-1)^(1) * 2^(1 - 3) * 0.1000
  // (-1)^(1) * 2^(0 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1000));
}
drivenby { // case 496
  x = (false@0b100@0b0111);
  y = (false@0b001@0b1111);
  // x + y
  //   +2.8750000) = (-1)^(0) * 2^(4 - 3) * 1.0111
  // +(+0.4843750) = (-1)^(0) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   +3.3593750) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // (-1)^(0) * 2^(4 - 3) * 11010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1011));
}
drivenby { // case 497
  x = (false@0b001@0b1000);
  y = (false@0b000@0b1011);
  // x + y
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // +(+0.1718750) = (-1)^(0) * 2^(1 - 3) * 0.1011
  // ----------------------------------------------
  //   +0.5468750) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // (-1)^(0) * 2^(2 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0010));
}
drivenby { // case 498
  x = (false@0b001@0b1001);
  y = (false@0b001@0b0101);
  // x + y
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // +(+0.3281250) = (-1)^(0) * 2^(1 - 3) * 1.0101
  // ----------------------------------------------
  //   +0.7187500) = (-1)^(0) * 2^(2 - 3) * 1.0111
  // (-1)^(0) * 2^(2 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0111));
}
drivenby { // case 499
  x = (true@0b000@0b0110);
  y = (false@0b000@0b0011);
  // x + y
  //   -0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // +(+0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // ----------------------------------------------
  //   -0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // (-1)^(1) * 2^(-2 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0011));
}
drivenby { // case 500
  x = (false@0b011@0b0110);
  y = (false@0b010@0b0001);
  // x + y
  //   +1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // +(+0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   +1.9062500) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // (-1)^(0) * 2^(3 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1110));
}
drivenby { // case 501
  x = (true@0b000@0b0101);
  y = (false@0b100@0b1100);
  // x + y
  //   -0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // +(+3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // ----------------------------------------------
  //   +3.4218750) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // (-1)^(0) * 2^(4 - 3) * 11011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1011));
}
drivenby { // case 502
  x = (true@0b000@0b1101);
  y = (false@0b000@0b0010);
  // x + y
  //   -0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // +(+0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // ----------------------------------------------
  //   -0.1718750) = (-1)^(1) * 2^(1 - 3) * 0.1011
  // (-1)^(1) * 2^(0 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1011));
}
drivenby { // case 503
  x = (true@0b000@0b0011);
  y = (false@0b000@0b1101);
  // x + y
  //   -0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // +(+0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   +0.1562500) = (-1)^(0) * 2^(1 - 3) * 0.1010
  // (-1)^(0) * 2^(0 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1010));
}
drivenby { // case 504
  x = (true@0b100@0b1101);
  y = (true@0b010@0b1000);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   -4.3750000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 505
  x = (true@0b100@0b0011);
  y = (false@0b000@0b0100);
  // x + y
  //   -2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // +(+0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   -2.3125000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // (-1)^(1) * 2^(4 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0010));
}
drivenby { // case 506
  x = (true@0b100@0b1111);
  y = (false@0b010@0b0001);
  // x + y
  //   -3.8750000) = (-1)^(1) * 2^(4 - 3) * 1.1111
  // +(+0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   -3.3437500) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // (-1)^(1) * 2^(4 - 3) * 11010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1011));
}
drivenby { // case 507
  x = (true@0b100@0b1100);
  y = (true@0b010@0b1110);
  // x + y
  //   -3.5000000) = (-1)^(1) * 2^(4 - 3) * 1.1100
  // +(-0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   -4.4375000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 508
  x = (true@0b011@0b0101);
  y = (true@0b001@0b1101);
  // x + y
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // +(-0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   -1.7656250) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // (-1)^(1) * 2^(3 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1100));
}
drivenby { // case 509
  x = (false@0b010@0b1001);
  y = (false@0b001@0b1011);
  // x + y
  //   +0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // +(+0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   +1.2031250) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // (-1)^(0) * 2^(3 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0011));
}
drivenby { // case 510
  x = (false@0b000@0b0010);
  y = (true@0b010@0b0000);
  // x + y
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // +(-0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.4687500) = (-1)^(1) * 2^(1 - 3) * 1.1110
  // (-1)^(1) * 2^(1 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1110));
}
drivenby { // case 511
  x = (false@0b101@0b1110);
  y = (true@0b000@0b0010);
  // x + y
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // +(-0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // ----------------------------------------------
  //   +7.4687500) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // (-1)^(0) * 2^(5 - 3) * 11101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1110));
}
drivenby { // case 512
  x = (false@0b011@0b0011);
  y = (false@0b010@0b0001);
  // x + y
  //   +1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // +(+0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   +1.7187500) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // (-1)^(0) * 2^(3 - 3) * 11011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1100));
}
drivenby { // case 513
  x = (true@0b001@0b0110);
  y = (false@0b001@0b1011);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(+0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // (-1)^(0) * 2^(-1 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0101));
}
drivenby { // case 514
  x = (true@0b101@0b0101);
  y = (true@0b001@0b0000);
  // x + y
  //   -5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // (-1)^(1) * 2^(5 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0110));
}
drivenby { // case 515
  x = (false@0b011@0b0010);
  y = (false@0b000@0b0001);
  // x + y
  //   +1.1250000) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // +(+0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   +1.1406250) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // (-1)^(0) * 2^(3 - 3) * 10010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0010));
}
drivenby { // case 516
  x = (true@0b000@0b0001);
  y = (true@0b011@0b1100);
  // x + y
  //   -0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // +(-1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   -1.7656250) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // (-1)^(1) * 2^(3 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1100));
}
drivenby { // case 517
  x = (false@0b000@0b1110);
  y = (true@0b010@0b1111);
  // x + y
  //   +0.2187500) = (-1)^(0) * 2^(1 - 3) * 0.1110
  // +(-0.9687500) = (-1)^(1) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   -0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // (-1)^(1) * 2^(2 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1000));
}
drivenby { // case 518
  x = (false@0b001@0b0111);
  y = (false@0b001@0b1010);
  // x + y
  //   +0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // +(+0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // ----------------------------------------------
  //   +0.7656250) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // (-1)^(0) * 2^(2 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1000));
}
drivenby { // case 519
  x = (true@0b011@0b0011);
  y = (false@0b000@0b0000);
  // x + y
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // +(+0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // (-1)^(1) * 2^(3 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0011));
}
drivenby { // case 520
  x = (false@0b000@0b1101);
  y = (true@0b101@0b0011);
  // x + y
  //   +0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // +(-4.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // ----------------------------------------------
  //   -4.5468750) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10010 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 521
  x = (false@0b100@0b0011);
  y = (false@0b011@0b1011);
  // x + y
  //   +2.3750000) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // +(+1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   +4.0625000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // (-1)^(0) * 2^(5 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0000));
}
drivenby { // case 522
  x = (true@0b010@0b1011);
  y = (false@0b011@0b1111);
  // x + y
  //   -0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // +(+1.9375000) = (-1)^(0) * 2^(3 - 3) * 1.1111
  // ----------------------------------------------
  //   +1.0937500) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // (-1)^(0) * 2^(3 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0010));
}
drivenby { // case 523
  x = (false@0b000@0b0011);
  y = (true@0b010@0b0110);
  // x + y
  //   +0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // +(-0.6875000) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   -0.6406250) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // (-1)^(1) * 2^(2 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0100));
}
drivenby { // case 524
  x = (true@0b000@0b0101);
  y = (false@0b100@0b1111);
  // x + y
  //   -0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // +(+3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   +3.7968750) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // (-1)^(0) * 2^(4 - 3) * 11110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1110));
}
drivenby { // case 525
  x = (true@0b101@0b1110);
  y = (false@0b100@0b1011);
  // x + y
  //   -7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // +(+3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   -4.1250000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(5 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 526
  x = (true@0b010@0b0111);
  y = (false@0b010@0b0000);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(+0.5000000) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // (-1)^(1) * 2^(0 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1110));
}
drivenby { // case 527
  x = (true@0b101@0b1100);
  y = (false@0b010@0b1110);
  // x + y
  //   -7.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // +(+0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   -6.0625000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // (-1)^(1) * 2^(5 - 3) * 11000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1000));
}
drivenby { // case 528
  x = (false@0b100@0b0110);
  y = (true@0b001@0b1010);
  // x + y
  //   +2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // +(-0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // ----------------------------------------------
  //   +2.3437500) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // (-1)^(0) * 2^(4 - 3) * 10010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0011));
}
drivenby { // case 529
  x = (true@0b100@0b0110);
  y = (true@0b010@0b1111);
  // x + y
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // +(-0.9687500) = (-1)^(1) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   -3.7187500) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // (-1)^(1) * 2^(4 - 3) * 11101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1110));
}
drivenby { // case 530
  x = (false@0b000@0b0010);
  y = (false@0b010@0b1000);
  // x + y
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // +(+0.7500000) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   +0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // (-1)^(0) * 2^(2 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1001));
}
drivenby { // case 531
  x = (true@0b011@0b1110);
  y = (false@0b101@0b1000);
  // x + y
  //   -1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // +(+6.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   +4.1250000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // (-1)^(0) * 2^(5 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0000));
}
drivenby { // case 532
  x = (true@0b011@0b0100);
  y = (true@0b101@0b1110);
  // x + y
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // +(-7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   -8.7500000) = (-1)^(1) * 2^(6 - 3) * 1.0010
  // (-1)^(1) * 2^(6 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0010));
}
drivenby { // case 533
  x = (true@0b001@0b0110);
  y = (true@0b100@0b0011);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(-2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // ----------------------------------------------
  //   -2.7187500) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 534
  x = (false@0b100@0b1111);
  y = (false@0b001@0b1101);
  // x + y
  //   +3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // +(+0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   +4.3281250) = (-1)^(0) * 2^(5 - 3) * 1.0001
  // (-1)^(0) * 2^(5 - 3) * 10001 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0001));
}
drivenby { // case 535
  x = (true@0b001@0b1111);
  y = (true@0b010@0b1111);
  // x + y
  //   -0.4843750) = (-1)^(1) * 2^(1 - 3) * 1.1111
  // +(-0.9687500) = (-1)^(1) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   -1.4531250) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // (-1)^(1) * 2^(3 - 3) * 10111 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0111));
}
drivenby { // case 536
  x = (true@0b001@0b0000);
  y = (true@0b100@0b0110);
  // x + y
  //   -0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // +(-2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // ----------------------------------------------
  //   -3.0000000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // (-1)^(1) * 2^(4 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1000));
}
drivenby { // case 537
  x = (false@0b001@0b1011);
  y = (false@0b100@0b1010);
  // x + y
  //   +0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // +(+3.2500000) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // ----------------------------------------------
  //   +3.6718750) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // (-1)^(0) * 2^(4 - 3) * 11101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1101));
}
drivenby { // case 538
  x = (false@0b100@0b0100);
  y = (false@0b101@0b1110);
  // x + y
  //   +2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // +(+7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   +10.0000000) = (-1)^(0) * 2^(6 - 3) * 1.0100
  // (-1)^(0) * 2^(6 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0100));
}
drivenby { // case 539
  x = (true@0b101@0b0000);
  y = (false@0b000@0b0010);
  // x + y
  //   -4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // +(+0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // ----------------------------------------------
  //   -3.9687500) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(4 - 3) * 11111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 540
  x = (true@0b001@0b1101);
  y = (true@0b101@0b0101);
  // x + y
  //   -0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // +(-5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   -5.7031250) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // (-1)^(1) * 2^(5 - 3) * 10110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0111));
}
drivenby { // case 541
  x = (false@0b010@0b1000);
  y = (true@0b010@0b1110);
  // x + y
  //   +0.7500000) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // +(-0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   -0.1875000) = (-1)^(1) * 2^(1 - 3) * 0.1100
  // (-1)^(1) * 2^(0 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1100));
}
drivenby { // case 542
  x = (true@0b010@0b0111);
  y = (false@0b010@0b0000);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(+0.5000000) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // (-1)^(1) * 2^(0 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1110));
}
drivenby { // case 543
  x = (false@0b000@0b0011);
  y = (false@0b100@0b1111);
  // x + y
  //   +0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // +(+3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   +3.9218750) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // (-1)^(0) * 2^(4 - 3) * 11111 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1111));
}
drivenby { // case 544
  x = (true@0b011@0b0111);
  y = (true@0b011@0b0011);
  // x + y
  //   -1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // +(-1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   -2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // (-1)^(1) * 2^(4 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0101));
}
drivenby { // case 545
  x = (true@0b000@0b0001);
  y = (false@0b001@0b1001);
  // x + y
  //   -0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // +(+0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // (-1)^(0) * 2^(1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1000));
}
drivenby { // case 546
  x = (true@0b010@0b0000);
  y = (true@0b001@0b0100);
  // x + y
  //   -0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // +(-0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   -0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // (-1)^(1) * 2^(2 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1010));
}
drivenby { // case 547
  x = (false@0b100@0b1110);
  y = (true@0b000@0b1001);
  // x + y
  //   +3.7500000) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // +(-0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // ----------------------------------------------
  //   +3.6093750) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // (-1)^(0) * 2^(4 - 3) * 11100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1101));
}
drivenby { // case 548
  x = (true@0b010@0b1110);
  y = (true@0b001@0b1000);
  // x + y
  //   -0.9375000) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // +(-0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 549
  x = (true@0b000@0b0001);
  y = (false@0b011@0b1110);
  // x + y
  //   -0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // +(+1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // ----------------------------------------------
  //   +1.8593750) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // (-1)^(0) * 2^(3 - 3) * 11101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1110));
}
drivenby { // case 550
  x = (true@0b010@0b0110);
  y = (true@0b010@0b1100);
  // x + y
  //   -0.6875000) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // +(-0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   -1.5625000) = (-1)^(1) * 2^(3 - 3) * 1.1001
  // (-1)^(1) * 2^(3 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1001));
}
drivenby { // case 551
  x = (true@0b011@0b1110);
  y = (true@0b001@0b1101);
  // x + y
  //   -1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // +(-0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   -2.3281250) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // (-1)^(1) * 2^(4 - 3) * 10010 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0011));
}
drivenby { // case 552
  x = (true@0b001@0b1111);
  y = (true@0b000@0b1111);
  // x + y
  //   -0.4843750) = (-1)^(1) * 2^(1 - 3) * 1.1111
  // +(-0.2343750) = (-1)^(1) * 2^(1 - 3) * 0.1111
  // ----------------------------------------------
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // (-1)^(1) * 2^(2 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0111));
}
drivenby { // case 553
  x = (true@0b010@0b0111);
  y = (true@0b011@0b1100);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(-1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   -2.4687500) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 554
  x = (true@0b010@0b1100);
  y = (false@0b100@0b1000);
  // x + y
  //   -0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // +(+3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // ----------------------------------------------
  //   +2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // (-1)^(0) * 2^(4 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0001));
}
drivenby { // case 555
  x = (false@0b001@0b0100);
  y = (false@0b001@0b1111);
  // x + y
  //   +0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // +(+0.4843750) = (-1)^(0) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   +0.7968750) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // (-1)^(0) * 2^(2 - 3) * 11001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1010));
}
drivenby { // case 556
  x = (false@0b000@0b0110);
  y = (false@0b011@0b0101);
  // x + y
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // +(+1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // ----------------------------------------------
  //   +1.4062500) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // (-1)^(0) * 2^(3 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0110));
}
drivenby { // case 557
  x = (true@0b010@0b1000);
  y = (false@0b001@0b1101);
  // x + y
  //   -0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // +(+0.4531250) = (-1)^(0) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   -0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // (-1)^(1) * 2^(1 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0011));
}
drivenby { // case 558
  x = (true@0b000@0b1001);
  y = (true@0b101@0b0000);
  // x + y
  //   -0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // +(-4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   -4.1406250) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10000 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 559
  x = (true@0b010@0b0101);
  y = (false@0b100@0b0111);
  // x + y
  //   -0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // +(+2.8750000) = (-1)^(0) * 2^(4 - 3) * 1.0111
  // ----------------------------------------------
  //   +2.2187500) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // (-1)^(0) * 2^(4 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0010));
}
drivenby { // case 560
  x = (false@0b000@0b1101);
  y = (false@0b100@0b0010);
  // x + y
  //   +0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +2.4531250) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // (-1)^(0) * 2^(4 - 3) * 10011 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0100));
}
drivenby { // case 561
  x = (true@0b101@0b0110);
  y = (false@0b001@0b0111);
  // x + y
  //   -5.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // +(+0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // ----------------------------------------------
  //   -5.1406250) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // (-1)^(1) * 2^(5 - 3) * 10100 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0101));
}
drivenby { // case 562
  x = (true@0b001@0b1001);
  y = (false@0b001@0b1010);
  // x + y
  //   -0.3906250) = (-1)^(1) * 2^(1 - 3) * 1.1001
  // +(+0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // ----------------------------------------------
  //   +0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // (-1)^(0) * 2^(-3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0001));
}
drivenby { // case 563
  x = (true@0b101@0b1100);
  y = (false@0b100@0b1101);
  // x + y
  //   -7.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // +(+3.6250000) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // ----------------------------------------------
  //   -3.3750000) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // (-1)^(1) * 2^(4 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1011));
}
drivenby { // case 564
  x = (false@0b011@0b0101);
  y = (true@0b101@0b0111);
  // x + y
  //   +1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // +(-5.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // ----------------------------------------------
  //   -4.4375000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 565
  x = (true@0b101@0b0001);
  y = (false@0b000@0b0100);
  // x + y
  //   -4.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // +(+0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   -4.1875000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 566
  x = (false@0b011@0b1100);
  y = (false@0b011@0b1000);
  // x + y
  //   +1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // +(+1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   +3.2500000) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // (-1)^(0) * 2^(4 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1010));
}
drivenby { // case 567
  x = (true@0b011@0b1001);
  y = (false@0b101@0b1110);
  // x + y
  //   -1.5625000) = (-1)^(1) * 2^(3 - 3) * 1.1001
  // +(+7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   +5.9375000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 10111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 568
  x = (false@0b000@0b0011);
  y = (false@0b010@0b1011);
  // x + y
  //   +0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // +(+0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.8906250) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // (-1)^(0) * 2^(2 - 3) * 11100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1100));
}
drivenby { // case 569
  x = (true@0b000@0b0011);
  y = (false@0b010@0b0110);
  // x + y
  //   -0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   +0.6406250) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // (-1)^(0) * 2^(2 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0100));
}
drivenby { // case 570
  x = (true@0b101@0b0010);
  y = (false@0b101@0b1110);
  // x + y
  //   -4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // +(+7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   +3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // (-1)^(0) * 2^(4 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1000));
}
drivenby { // case 571
  x = (true@0b101@0b1001);
  y = (false@0b011@0b0001);
  // x + y
  //   -6.2500000) = (-1)^(1) * 2^(5 - 3) * 1.1001
  // +(+1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   -5.1875000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // (-1)^(1) * 2^(5 - 3) * 10100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0101));
}
drivenby { // case 572
  x = (false@0b000@0b1101);
  y = (true@0b100@0b1101);
  // x + y
  //   +0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // +(-3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // ----------------------------------------------
  //   -3.4218750) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // (-1)^(1) * 2^(4 - 3) * 11011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1011));
}
drivenby { // case 573
  x = (true@0b010@0b0111);
  y = (true@0b000@0b1101);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(-0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   -0.9218750) = (-1)^(1) * 2^(2 - 3) * 1.1110
  // (-1)^(1) * 2^(2 - 3) * 11101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1110));
}
drivenby { // case 574
  x = (false@0b001@0b1001);
  y = (true@0b011@0b0111);
  // x + y
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // +(-1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   -1.0468750) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // (-1)^(1) * 2^(3 - 3) * 10000 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0001));
}
drivenby { // case 575
  x = (false@0b000@0b0110);
  y = (false@0b100@0b0011);
  // x + y
  //   +0.0937500) = (-1)^(0) * 2^(1 - 3) * 0.0110
  // +(+2.3750000) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // ----------------------------------------------
  //   +2.4687500) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // (-1)^(0) * 2^(4 - 3) * 10011 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0100));
}
drivenby { // case 576
  x = (false@0b011@0b1110);
  y = (true@0b101@0b0011);
  // x + y
  //   +1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // +(-4.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0011
  // ----------------------------------------------
  //   -2.8750000) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // (-1)^(1) * 2^(4 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0111));
}
drivenby { // case 577
  x = (false@0b001@0b1001);
  y = (false@0b010@0b1001);
  // x + y
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // +(+0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   +1.1718750) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // (-1)^(0) * 2^(3 - 3) * 10010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0011));
}
drivenby { // case 578
  x = (true@0b100@0b1101);
  y = (false@0b001@0b0001);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(+0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // ----------------------------------------------
  //   -3.3593750) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // (-1)^(1) * 2^(4 - 3) * 11010 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1011));
}
drivenby { // case 579
  x = (true@0b101@0b0010);
  y = (true@0b101@0b0101);
  // x + y
  //   -4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // +(-5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   -9.7500000) = (-1)^(1) * 2^(6 - 3) * 1.0100
  // (-1)^(1) * 2^(6 - 3) * 10011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0100));
}
drivenby { // case 580
  x = (false@0b001@0b0001);
  y = (true@0b001@0b0111);
  // x + y
  //   +0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // +(-0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // ----------------------------------------------
  //   -0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // (-1)^(1) * 2^(-1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0110));
}
drivenby { // case 581
  x = (false@0b001@0b0001);
  y = (true@0b000@0b0101);
  // x + y
  //   +0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // +(-0.0781250) = (-1)^(1) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   +0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // (-1)^(0) * 2^(0 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1100));
}
drivenby { // case 582
  x = (false@0b101@0b1100);
  y = (false@0b011@0b1110);
  // x + y
  //   +7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // +(+1.8750000) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // ----------------------------------------------
  //   +8.8750000) = (-1)^(0) * 2^(6 - 3) * 1.0010
  // (-1)^(0) * 2^(6 - 3) * 10001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0010));
}
drivenby { // case 583
  x = (true@0b001@0b0000);
  y = (true@0b001@0b1001);
  // x + y
  //   -0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // +(-0.3906250) = (-1)^(1) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   -0.6406250) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // (-1)^(1) * 2^(2 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0100));
}
drivenby { // case 584
  x = (false@0b101@0b0101);
  y = (true@0b000@0b1101);
  // x + y
  //   +5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // +(-0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   +5.0468750) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 585
  x = (false@0b000@0b0111);
  y = (false@0b011@0b0110);
  // x + y
  //   +0.1093750) = (-1)^(0) * 2^(1 - 3) * 0.0111
  // +(+1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   +1.4843750) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // (-1)^(0) * 2^(3 - 3) * 10111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1000));
}
drivenby { // case 586
  x = (true@0b000@0b1110);
  y = (false@0b011@0b1101);
  // x + y
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // +(+1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // ----------------------------------------------
  //   +1.5937500) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // (-1)^(0) * 2^(3 - 3) * 11001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1010));
}
drivenby { // case 587
  x = (true@0b011@0b1000);
  y = (true@0b101@0b1000);
  // x + y
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // +(-6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   -7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // (-1)^(1) * 2^(5 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1110));
}
drivenby { // case 588
  x = (true@0b011@0b1001);
  y = (false@0b100@0b0010);
  // x + y
  //   -1.5625000) = (-1)^(1) * 2^(3 - 3) * 1.1001
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // (-1)^(0) * 2^(2 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0110));
}
drivenby { // case 589
  x = (true@0b010@0b1111);
  y = (false@0b001@0b1001);
  // x + y
  //   -0.9687500) = (-1)^(1) * 2^(2 - 3) * 1.1111
  // +(+0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   -0.5781250) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // (-1)^(1) * 2^(2 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0010));
}
drivenby { // case 590
  x = (false@0b000@0b1100);
  y = (true@0b010@0b0111);
  // x + y
  //   +0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // +(-0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   -0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // (-1)^(1) * 2^(2 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0001));
}
drivenby { // case 591
  x = (true@0b011@0b1011);
  y = (false@0b010@0b0010);
  // x + y
  //   -1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // +(+0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // ----------------------------------------------
  //   -1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // (-1)^(1) * 2^(3 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0010));
}
drivenby { // case 592
  x = (false@0b101@0b0000);
  y = (false@0b100@0b1101);
  // x + y
  //   +4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // +(+3.6250000) = (-1)^(0) * 2^(4 - 3) * 1.1101
  // ----------------------------------------------
  //   +7.6250000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // (-1)^(0) * 2^(5 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1110));
}
drivenby { // case 593
  x = (false@0b001@0b0100);
  y = (true@0b011@0b0010);
  // x + y
  //   +0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // +(-1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // ----------------------------------------------
  //   -0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // (-1)^(1) * 2^(2 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1010));
}
drivenby { // case 594
  x = (false@0b001@0b1001);
  y = (true@0b001@0b1010);
  // x + y
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // +(-0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // ----------------------------------------------
  //   -0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // (-1)^(1) * 2^(-3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0001));
}
drivenby { // case 595
  x = (true@0b000@0b0110);
  y = (true@0b001@0b0000);
  // x + y
  //   -0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // (-1)^(1) * 2^(1 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0110));
}
drivenby { // case 596
  x = (false@0b001@0b1110);
  y = (false@0b101@0b0110);
  // x + y
  //   +0.4687500) = (-1)^(0) * 2^(1 - 3) * 1.1110
  // +(+5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   +5.9687500) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 10111 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 597
  x = (false@0b001@0b0011);
  y = (false@0b100@0b0001);
  // x + y
  //   +0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // +(+2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // ----------------------------------------------
  //   +2.4218750) = (-1)^(0) * 2^(4 - 3) * 1.0011
  // (-1)^(0) * 2^(4 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0011));
}
drivenby { // case 598
  x = (false@0b100@0b1110);
  y = (false@0b100@0b1100);
  // x + y
  //   +3.7500000) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // +(+3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // ----------------------------------------------
  //   +7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // (-1)^(0) * 2^(5 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1101));
}
drivenby { // case 599
  x = (true@0b010@0b0011);
  y = (false@0b001@0b1000);
  // x + y
  //   -0.5937500) = (-1)^(1) * 2^(2 - 3) * 1.0011
  // +(+0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // ----------------------------------------------
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // (-1)^(1) * 2^(0 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1110));
}
drivenby { // case 600
  x = (false@0b100@0b0110);
  y = (true@0b011@0b1100);
  // x + y
  //   +2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // +(-1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   +1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 601
  x = (true@0b000@0b0111);
  y = (true@0b000@0b0110);
  // x + y
  //   -0.1093750) = (-1)^(1) * 2^(1 - 3) * 0.0111
  // +(-0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // ----------------------------------------------
  //   -0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // (-1)^(1) * 2^(0 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1101));
}
drivenby { // case 602
  x = (true@0b000@0b1001);
  y = (false@0b011@0b1000);
  // x + y
  //   -0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // +(+1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   +1.3593750) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // (-1)^(0) * 2^(3 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0110));
}
drivenby { // case 603
  x = (true@0b001@0b0110);
  y = (false@0b001@0b0110);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(+0.3437500) = (-1)^(0) * 2^(1 - 3) * 1.0110
  // ----------------------------------------------
  //   +0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // (-1)^(0) * 2^(3 - 3) * 00000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0000));
}
drivenby { // case 604
  x = (false@0b000@0b0101);
  y = (true@0b000@0b1001);
  // x + y
  //   +0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // +(-0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // ----------------------------------------------
  //   -0.0625000) = (-1)^(1) * 2^(1 - 3) * 0.0100
  // (-1)^(1) * 2^(-1 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0100));
}
drivenby { // case 605
  x = (true@0b011@0b0110);
  y = (false@0b000@0b0000);
  // x + y
  //   -1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // +(+0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   -1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // (-1)^(1) * 2^(3 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0110));
}
drivenby { // case 606
  x = (false@0b011@0b0110);
  y = (true@0b011@0b0100);
  // x + y
  //   +1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // +(-1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // ----------------------------------------------
  //   +0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // (-1)^(0) * 2^(0 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1000));
}
drivenby { // case 607
  x = (true@0b010@0b1100);
  y = (true@0b011@0b1111);
  // x + y
  //   -0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // +(-1.9375000) = (-1)^(1) * 2^(3 - 3) * 1.1111
  // ----------------------------------------------
  //   -2.8125000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 608
  x = (true@0b000@0b1101);
  y = (false@0b000@0b0001);
  // x + y
  //   -0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // +(+0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   -0.1875000) = (-1)^(1) * 2^(1 - 3) * 0.1100
  // (-1)^(1) * 2^(0 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1100));
}
drivenby { // case 609
  x = (false@0b100@0b1000);
  y = (true@0b101@0b0111);
  // x + y
  //   +3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // +(-5.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // ----------------------------------------------
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 610
  x = (true@0b011@0b1000);
  y = (true@0b101@0b1000);
  // x + y
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // +(-6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   -7.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1110
  // (-1)^(1) * 2^(5 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1110));
}
drivenby { // case 611
  x = (true@0b011@0b0111);
  y = (true@0b010@0b0100);
  // x + y
  //   -1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // +(-0.6250000) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // ----------------------------------------------
  //   -2.0625000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // (-1)^(1) * 2^(4 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0000));
}
drivenby { // case 612
  x = (true@0b011@0b0101);
  y = (false@0b011@0b1100);
  // x + y
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // +(+1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   +0.4375000) = (-1)^(0) * 2^(1 - 3) * 1.1100
  // (-1)^(0) * 2^(1 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1100));
}
drivenby { // case 613
  x = (true@0b010@0b1010);
  y = (false@0b000@0b1111);
  // x + y
  //   -0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // +(+0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // ----------------------------------------------
  //   -0.5781250) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // (-1)^(1) * 2^(2 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0010));
}
drivenby { // case 614
  x = (false@0b101@0b0101);
  y = (false@0b000@0b1000);
  // x + y
  //   +5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // +(+0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // ----------------------------------------------
  //   +5.3750000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 615
  x = (true@0b001@0b1010);
  y = (true@0b000@0b0011);
  // x + y
  //   -0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // +(-0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // ----------------------------------------------
  //   -0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // (-1)^(1) * 2^(1 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1101));
}
drivenby { // case 616
  x = (true@0b000@0b1010);
  y = (true@0b011@0b0000);
  // x + y
  //   -0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // +(-1.0000000) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // ----------------------------------------------
  //   -1.1562500) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // (-1)^(1) * 2^(3 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0010));
}
drivenby { // case 617
  x = (true@0b101@0b0111);
  y = (false@0b011@0b1100);
  // x + y
  //   -5.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // +(+1.7500000) = (-1)^(0) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   -4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(5 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 618
  x = (false@0b100@0b0111);
  y = (true@0b010@0b1101);
  // x + y
  //   +2.8750000) = (-1)^(0) * 2^(4 - 3) * 1.0111
  // +(-0.9062500) = (-1)^(1) * 2^(2 - 3) * 1.1101
  // ----------------------------------------------
  //   +1.9687500) = (-1)^(0) * 2^(4 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 11111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0000));
}
drivenby { // case 619
  x = (false@0b100@0b0110);
  y = (true@0b011@0b1100);
  // x + y
  //   +2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // +(-1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // ----------------------------------------------
  //   +1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 620
  x = (false@0b100@0b0001);
  y = (false@0b100@0b1100);
  // x + y
  //   +2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // +(+3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // ----------------------------------------------
  //   +5.6250000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 621
  x = (true@0b001@0b1100);
  y = (true@0b010@0b0111);
  // x + y
  //   -0.4375000) = (-1)^(1) * 2^(1 - 3) * 1.1100
  // +(-0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   -1.1562500) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // (-1)^(1) * 2^(3 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0010));
}
drivenby { // case 622
  x = (true@0b100@0b0010);
  y = (true@0b100@0b1001);
  // x + y
  //   -2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // +(-3.1250000) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // ----------------------------------------------
  //   -5.3750000) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // (-1)^(1) * 2^(5 - 3) * 10101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0110));
}
drivenby { // case 623
  x = (true@0b011@0b1100);
  y = (false@0b000@0b1010);
  // x + y
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // +(+0.1562500) = (-1)^(0) * 2^(1 - 3) * 0.1010
  // ----------------------------------------------
  //   -1.5937500) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // (-1)^(1) * 2^(3 - 3) * 11001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1010));
}
drivenby { // case 624
  x = (false@0b010@0b0101);
  y = (false@0b101@0b0110);
  // x + y
  //   +0.6562500) = (-1)^(0) * 2^(2 - 3) * 1.0101
  // +(+5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   +6.1562500) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // (-1)^(0) * 2^(5 - 3) * 11000 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1001));
}
drivenby { // case 625
  x = (true@0b100@0b1110);
  y = (false@0b010@0b0110);
  // x + y
  //   -3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // +(+0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // ----------------------------------------------
  //   -3.0625000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // (-1)^(1) * 2^(4 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1000));
}
drivenby { // case 626
  x = (false@0b010@0b0110);
  y = (false@0b001@0b0100);
  // x + y
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   +1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 627
  x = (false@0b101@0b0110);
  y = (false@0b000@0b0000);
  // x + y
  //   +5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // +(+0.0000000) = (-1)^(0) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   +5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 628
  x = (false@0b001@0b0000);
  y = (false@0b000@0b0111);
  // x + y
  //   +0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // +(+0.1093750) = (-1)^(0) * 2^(1 - 3) * 0.0111
  // ----------------------------------------------
  //   +0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // (-1)^(0) * 2^(1 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0111));
}
drivenby { // case 629
  x = (false@0b100@0b1010);
  y = (true@0b100@0b1001);
  // x + y
  //   +3.2500000) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // +(-3.1250000) = (-1)^(1) * 2^(4 - 3) * 1.1001
  // ----------------------------------------------
  //   +0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // (-1)^(0) * 2^(0 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1000));
}
drivenby { // case 630
  x = (true@0b001@0b1101);
  y = (false@0b010@0b0000);
  // x + y
  //   -0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // +(+0.5000000) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   +0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // (-1)^(0) * 2^(-2 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0011));
}
drivenby { // case 631
  x = (false@0b000@0b0100);
  y = (false@0b101@0b1001);
  // x + y
  //   +0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // +(+6.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // ----------------------------------------------
  //   +6.3125000) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // (-1)^(0) * 2^(5 - 3) * 11001 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1001));
}
drivenby { // case 632
  x = (true@0b011@0b0100);
  y = (true@0b101@0b0000);
  // x + y
  //   -1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // +(-4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   -5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // (-1)^(1) * 2^(5 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0101));
}
drivenby { // case 633
  x = (false@0b001@0b1010);
  y = (false@0b011@0b1000);
  // x + y
  //   +0.4062500) = (-1)^(0) * 2^(1 - 3) * 1.1010
  // +(+1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // ----------------------------------------------
  //   +1.9062500) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // (-1)^(0) * 2^(3 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1110));
}
drivenby { // case 634
  x = (false@0b100@0b1000);
  y = (false@0b011@0b0000);
  // x + y
  //   +3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // +(+1.0000000) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // ----------------------------------------------
  //   +4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // (-1)^(0) * 2^(5 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0000));
}
drivenby { // case 635
  x = (false@0b101@0b1110);
  y = (true@0b101@0b0010);
  // x + y
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // +(-4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // ----------------------------------------------
  //   +3.0000000) = (-1)^(0) * 2^(4 - 3) * 1.1000
  // (-1)^(0) * 2^(4 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1000));
}
drivenby { // case 636
  x = (true@0b001@0b1000);
  y = (true@0b010@0b1101);
  // x + y
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // +(-0.9062500) = (-1)^(1) * 2^(2 - 3) * 1.1101
  // ----------------------------------------------
  //   -1.2812500) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 637
  x = (true@0b001@0b1000);
  y = (true@0b000@0b0110);
  // x + y
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // +(-0.0937500) = (-1)^(1) * 2^(1 - 3) * 0.0110
  // ----------------------------------------------
  //   -0.4687500) = (-1)^(1) * 2^(1 - 3) * 1.1110
  // (-1)^(1) * 2^(1 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1110));
}
drivenby { // case 638
  x = (false@0b001@0b0001);
  y = (false@0b101@0b0101);
  // x + y
  //   +0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // +(+5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   +5.5156250) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10110 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 639
  x = (false@0b010@0b1011);
  y = (false@0b000@0b1100);
  // x + y
  //   +0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // +(+0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // ----------------------------------------------
  //   +1.0312500) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 640
  x = (false@0b000@0b0001);
  y = (false@0b100@0b1010);
  // x + y
  //   +0.0156250) = (-1)^(0) * 2^(1 - 3) * 0.0001
  // +(+3.2500000) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // ----------------------------------------------
  //   +3.2656250) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // (-1)^(0) * 2^(4 - 3) * 11010 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1010));
}
drivenby { // case 641
  x = (false@0b011@0b0100);
  y = (true@0b001@0b0110);
  // x + y
  //   +1.2500000) = (-1)^(0) * 2^(3 - 3) * 1.0100
  // +(-0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // ----------------------------------------------
  //   +0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // (-1)^(0) * 2^(2 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1101));
}
drivenby { // case 642
  x = (false@0b000@0b1010);
  y = (true@0b101@0b0111);
  // x + y
  //   +0.1562500) = (-1)^(0) * 2^(1 - 3) * 0.1010
  // +(-5.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // ----------------------------------------------
  //   -5.5937500) = (-1)^(1) * 2^(5 - 3) * 1.0110
  // (-1)^(1) * 2^(5 - 3) * 10110 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0110));
}
drivenby { // case 643
  x = (true@0b011@0b1110);
  y = (false@0b101@0b1010);
  // x + y
  //   -1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // +(+6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // ----------------------------------------------
  //   +4.6250000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // (-1)^(0) * 2^(5 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0010));
}
drivenby { // case 644
  x = (true@0b011@0b1000);
  y = (false@0b011@0b0010);
  // x + y
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // +(+1.1250000) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // ----------------------------------------------
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // (-1)^(1) * 2^(1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1000));
}
drivenby { // case 645
  x = (true@0b000@0b0001);
  y = (false@0b010@0b0111);
  // x + y
  //   -0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // +(+0.7187500) = (-1)^(0) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   +0.7031250) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // (-1)^(0) * 2^(2 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0110));
}
drivenby { // case 646
  x = (true@0b011@0b1110);
  y = (true@0b010@0b0001);
  // x + y
  //   -1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // +(-0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   -2.4062500) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // (-1)^(1) * 2^(4 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0011));
}
drivenby { // case 647
  x = (true@0b010@0b1001);
  y = (false@0b011@0b1011);
  // x + y
  //   -0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // +(+1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.9062500) = (-1)^(0) * 2^(2 - 3) * 1.1101
  // (-1)^(0) * 2^(2 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1101));
}
drivenby { // case 648
  x = (true@0b010@0b0110);
  y = (false@0b101@0b0110);
  // x + y
  //   -0.6875000) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // +(+5.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // ----------------------------------------------
  //   +4.8125000) = (-1)^(0) * 2^(5 - 3) * 1.0011
  // (-1)^(0) * 2^(5 - 3) * 10011 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0011));
}
drivenby { // case 649
  x = (false@0b010@0b0001);
  y = (false@0b011@0b0001);
  // x + y
  //   +0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // +(+1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   +1.5937500) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // (-1)^(0) * 2^(3 - 3) * 11001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1010));
}
drivenby { // case 650
  x = (false@0b000@0b0010);
  y = (true@0b000@0b1101);
  // x + y
  //   +0.0312500) = (-1)^(0) * 2^(1 - 3) * 0.0010
  // +(-0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   -0.1718750) = (-1)^(1) * 2^(1 - 3) * 0.1011
  // (-1)^(1) * 2^(0 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1011));
}
drivenby { // case 651
  x = (false@0b001@0b0110);
  y = (true@0b000@0b0111);
  // x + y
  //   +0.3437500) = (-1)^(0) * 2^(1 - 3) * 1.0110
  // +(-0.1093750) = (-1)^(1) * 2^(1 - 3) * 0.0111
  // ----------------------------------------------
  //   +0.2343750) = (-1)^(0) * 2^(1 - 3) * 0.1111
  // (-1)^(0) * 2^(0 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b1111));
}
drivenby { // case 652
  x = (false@0b001@0b0001);
  y = (false@0b011@0b0110);
  // x + y
  //   +0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // +(+1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   +1.6406250) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // (-1)^(0) * 2^(3 - 3) * 11010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1010));
}
drivenby { // case 653
  x = (true@0b101@0b1011);
  y = (true@0b001@0b0000);
  // x + y
  //   -6.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1011
  // +(-0.2500000) = (-1)^(1) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -7.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // (-1)^(1) * 2^(5 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1100));
}
drivenby { // case 654
  x = (true@0b011@0b1010);
  y = (true@0b101@0b0101);
  // x + y
  //   -1.6250000) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // +(-5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   -6.8750000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // (-1)^(1) * 2^(5 - 3) * 11011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1100));
}
drivenby { // case 655
  x = (false@0b011@0b1001);
  y = (true@0b011@0b1010);
  // x + y
  //   +1.5625000) = (-1)^(0) * 2^(3 - 3) * 1.1001
  // +(-1.6250000) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // ----------------------------------------------
  //   -0.0625000) = (-1)^(1) * 2^(1 - 3) * 0.0100
  // (-1)^(1) * 2^(-1 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0100));
}
drivenby { // case 656
  x = (false@0b011@0b0001);
  y = (true@0b000@0b0010);
  // x + y
  //   +1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // +(-0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // ----------------------------------------------
  //   +1.0312500) = (-1)^(0) * 2^(3 - 3) * 1.0000
  // (-1)^(0) * 2^(3 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0000));
}
drivenby { // case 657
  x = (true@0b011@0b0111);
  y = (false@0b011@0b0001);
  // x + y
  //   -1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // +(+1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // (-1)^(1) * 2^(1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1000));
}
drivenby { // case 658
  x = (true@0b100@0b1000);
  y = (false@0b011@0b1011);
  // x + y
  //   -3.0000000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // +(+1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 659
  x = (false@0b001@0b0100);
  y = (false@0b000@0b0101);
  // x + y
  //   +0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // +(+0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   +0.3906250) = (-1)^(0) * 2^(1 - 3) * 1.1001
  // (-1)^(0) * 2^(1 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1001));
}
drivenby { // case 660
  x = (false@0b010@0b0010);
  y = (true@0b001@0b1101);
  // x + y
  //   +0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // +(-0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   +0.1093750) = (-1)^(0) * 2^(1 - 3) * 0.0111
  // (-1)^(0) * 2^(-1 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b000@0b0111));
}
drivenby { // case 661
  x = (true@0b001@0b0011);
  y = (true@0b000@0b0000);
  // x + y
  //   -0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // +(-0.0000000) = (-1)^(1) * 2^(1 - 3) * 0.0000
  // ----------------------------------------------
  //   -0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // (-1)^(1) * 2^(1 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0011));
}
drivenby { // case 662
  x = (true@0b010@0b1010);
  y = (false@0b000@0b0011);
  // x + y
  //   -0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // +(+0.0468750) = (-1)^(0) * 2^(1 - 3) * 0.0011
  // ----------------------------------------------
  //   -0.7656250) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // (-1)^(1) * 2^(2 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1000));
}
drivenby { // case 663
  x = (true@0b011@0b0011);
  y = (true@0b011@0b0101);
  // x + y
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // +(-1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // ----------------------------------------------
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // (-1)^(1) * 2^(4 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0100));
}
drivenby { // case 664
  x = (false@0b011@0b0010);
  y = (false@0b010@0b1100);
  // x + y
  //   +1.1250000) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // +(+0.8750000) = (-1)^(0) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   +2.0000000) = (-1)^(0) * 2^(4 - 3) * 1.0000
  // (-1)^(0) * 2^(4 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0000));
}
drivenby { // case 665
  x = (true@0b100@0b0100);
  y = (false@0b101@0b1111);
  // x + y
  //   -2.5000000) = (-1)^(1) * 2^(4 - 3) * 1.0100
  // +(+7.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1111
  // ----------------------------------------------
  //   +5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // (-1)^(0) * 2^(5 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0101));
}
drivenby { // case 666
  x = (true@0b011@0b1000);
  y = (false@0b010@0b0111);
  // x + y
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // +(+0.7187500) = (-1)^(0) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   -0.7812500) = (-1)^(1) * 2^(2 - 3) * 1.1001
  // (-1)^(1) * 2^(2 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1001));
}
drivenby { // case 667
  x = (false@0b011@0b1001);
  y = (false@0b001@0b1111);
  // x + y
  //   +1.5625000) = (-1)^(0) * 2^(3 - 3) * 1.1001
  // +(+0.4843750) = (-1)^(0) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   +2.0468750) = (-1)^(0) * 2^(4 - 3) * 1.0000
  // (-1)^(0) * 2^(4 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0000));
}
drivenby { // case 668
  x = (false@0b001@0b0001);
  y = (true@0b100@0b1000);
  // x + y
  //   +0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // +(-3.0000000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // ----------------------------------------------
  //   -2.7343750) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 669
  x = (false@0b011@0b0110);
  y = (false@0b001@0b0100);
  // x + y
  //   +1.3750000) = (-1)^(0) * 2^(3 - 3) * 1.0110
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   +1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // (-1)^(0) * 2^(3 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1011));
}
drivenby { // case 670
  x = (false@0b001@0b1000);
  y = (false@0b001@0b1011);
  // x + y
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // +(+0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // ----------------------------------------------
  //   +0.7968750) = (-1)^(0) * 2^(2 - 3) * 1.1010
  // (-1)^(0) * 2^(2 - 3) * 11001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1010));
}
drivenby { // case 671
  x = (true@0b000@0b1100);
  y = (false@0b101@0b0000);
  // x + y
  //   -0.1875000) = (-1)^(1) * 2^(1 - 3) * 0.1100
  // +(+4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   +3.8125000) = (-1)^(0) * 2^(4 - 3) * 1.1110
  // (-1)^(0) * 2^(4 - 3) * 11110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1110));
}
drivenby { // case 672
  x = (true@0b001@0b0111);
  y = (false@0b101@0b0101);
  // x + y
  //   -0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // +(+5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   +4.8906250) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10011 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 673
  x = (true@0b001@0b1010);
  y = (false@0b101@0b1110);
  // x + y
  //   -0.4062500) = (-1)^(1) * 2^(1 - 3) * 1.1010
  // +(+7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // ----------------------------------------------
  //   +7.0937500) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // (-1)^(0) * 2^(5 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1100));
}
drivenby { // case 674
  x = (true@0b011@0b1101);
  y = (true@0b010@0b1011);
  // x + y
  //   -1.8125000) = (-1)^(1) * 2^(3 - 3) * 1.1101
  // +(-0.8437500) = (-1)^(1) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   -2.6562500) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // (-1)^(1) * 2^(4 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0101));
}
drivenby { // case 675
  x = (true@0b100@0b0010);
  y = (true@0b001@0b0101);
  // x + y
  //   -2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // +(-0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // ----------------------------------------------
  //   -2.5781250) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // (-1)^(1) * 2^(4 - 3) * 10100 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0101));
}
drivenby { // case 676
  x = (false@0b010@0b0001);
  y = (true@0b100@0b1010);
  // x + y
  //   +0.5312500) = (-1)^(0) * 2^(2 - 3) * 1.0001
  // +(-3.2500000) = (-1)^(1) * 2^(4 - 3) * 1.1010
  // ----------------------------------------------
  //   -2.7187500) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 677
  x = (true@0b011@0b0001);
  y = (true@0b001@0b0001);
  // x + y
  //   -1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // +(-0.2656250) = (-1)^(1) * 2^(1 - 3) * 1.0001
  // ----------------------------------------------
  //   -1.3281250) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 678
  x = (false@0b001@0b0000);
  y = (false@0b001@0b0011);
  // x + y
  //   +0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // +(+0.2968750) = (-1)^(0) * 2^(1 - 3) * 1.0011
  // ----------------------------------------------
  //   +0.5468750) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // (-1)^(0) * 2^(2 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0010));
}
drivenby { // case 679
  x = (false@0b000@0b0111);
  y = (false@0b101@0b0101);
  // x + y
  //   +0.1093750) = (-1)^(0) * 2^(1 - 3) * 0.0111
  // +(+5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   +5.3593750) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // (-1)^(0) * 2^(5 - 3) * 10101 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0101));
}
drivenby { // case 680
  x = (true@0b000@0b1000);
  y = (true@0b101@0b1000);
  // x + y
  //   -0.1250000) = (-1)^(1) * 2^(1 - 3) * 0.1000
  // +(-6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   -6.1250000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // (-1)^(1) * 2^(5 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1000));
}
drivenby { // case 681
  x = (false@0b100@0b1001);
  y = (true@0b011@0b1011);
  // x + y
  //   +3.1250000) = (-1)^(0) * 2^(4 - 3) * 1.1001
  // +(-1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   +1.4375000) = (-1)^(0) * 2^(3 - 3) * 1.0111
  // (-1)^(0) * 2^(3 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0111));
}
drivenby { // case 682
  x = (false@0b010@0b0111);
  y = (true@0b011@0b0100);
  // x + y
  //   +0.7187500) = (-1)^(0) * 2^(2 - 3) * 1.0111
  // +(-1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // ----------------------------------------------
  //   -0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // (-1)^(1) * 2^(2 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0001));
}
drivenby { // case 683
  x = (false@0b011@0b0011);
  y = (true@0b101@0b0101);
  // x + y
  //   +1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // +(-5.2500000) = (-1)^(1) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   -4.0625000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(5 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 684
  x = (false@0b000@0b1000);
  y = (true@0b100@0b1111);
  // x + y
  //   +0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // +(-3.8750000) = (-1)^(1) * 2^(4 - 3) * 1.1111
  // ----------------------------------------------
  //   -3.7500000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // (-1)^(1) * 2^(4 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1110));
}
drivenby { // case 685
  x = (false@0b011@0b0001);
  y = (false@0b100@0b0001);
  // x + y
  //   +1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // +(+2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // ----------------------------------------------
  //   +3.1875000) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // (-1)^(0) * 2^(4 - 3) * 11001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1010));
}
drivenby { // case 686
  x = (false@0b000@0b0100);
  y = (true@0b001@0b0010);
  // x + y
  //   +0.0625000) = (-1)^(0) * 2^(1 - 3) * 0.0100
  // +(-0.2812500) = (-1)^(1) * 2^(1 - 3) * 1.0010
  // ----------------------------------------------
  //   -0.2187500) = (-1)^(1) * 2^(1 - 3) * 0.1110
  // (-1)^(1) * 2^(0 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b1110));
}
drivenby { // case 687
  x = (true@0b011@0b1100);
  y = (false@0b001@0b0000);
  // x + y
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // +(+0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // ----------------------------------------------
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // (-1)^(1) * 2^(3 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1000));
}
drivenby { // case 688
  x = (false@0b011@0b0001);
  y = (false@0b000@0b0101);
  // x + y
  //   +1.0625000) = (-1)^(0) * 2^(3 - 3) * 1.0001
  // +(+0.0781250) = (-1)^(0) * 2^(1 - 3) * 0.0101
  // ----------------------------------------------
  //   +1.1406250) = (-1)^(0) * 2^(3 - 3) * 1.0010
  // (-1)^(0) * 2^(3 - 3) * 10010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0010));
}
drivenby { // case 689
  x = (true@0b001@0b1011);
  y = (false@0b010@0b1111);
  // x + y
  //   -0.4218750) = (-1)^(1) * 2^(1 - 3) * 1.1011
  // +(+0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   +0.5468750) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // (-1)^(0) * 2^(2 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b0010));
}
drivenby { // case 690
  x = (true@0b101@0b0010);
  y = (true@0b011@0b0110);
  // x + y
  //   -4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // +(-1.3750000) = (-1)^(1) * 2^(3 - 3) * 1.0110
  // ----------------------------------------------
  //   -5.8750000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // (-1)^(1) * 2^(5 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1000));
}
drivenby { // case 691
  x = (false@0b001@0b0000);
  y = (true@0b011@0b0001);
  // x + y
  //   +0.2500000) = (-1)^(0) * 2^(1 - 3) * 1.0000
  // +(-1.0625000) = (-1)^(1) * 2^(3 - 3) * 1.0001
  // ----------------------------------------------
  //   -0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // (-1)^(1) * 2^(2 - 3) * 11010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1010));
}
drivenby { // case 692
  x = (true@0b010@0b0101);
  y = (true@0b100@0b1100);
  // x + y
  //   -0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // +(-3.5000000) = (-1)^(1) * 2^(4 - 3) * 1.1100
  // ----------------------------------------------
  //   -4.1562500) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10000 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 693
  x = (true@0b010@0b0111);
  y = (true@0b010@0b1000);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(-0.7500000) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // ----------------------------------------------
  //   -1.4687500) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // (-1)^(1) * 2^(3 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1000));
}
drivenby { // case 694
  x = (false@0b001@0b0001);
  y = (true@0b010@0b0001);
  // x + y
  //   +0.2656250) = (-1)^(0) * 2^(1 - 3) * 1.0001
  // +(-0.5312500) = (-1)^(1) * 2^(2 - 3) * 1.0001
  // ----------------------------------------------
  //   -0.2656250) = (-1)^(1) * 2^(1 - 3) * 1.0001
  // (-1)^(1) * 2^(1 - 3) * 10001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0001));
}
drivenby { // case 695
  x = (false@0b101@0b1110);
  y = (false@0b010@0b1001);
  // x + y
  //   +7.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1110
  // +(+0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   +8.2812500) = (-1)^(0) * 2^(6 - 3) * 1.0001
  // (-1)^(0) * 2^(6 - 3) * 10000 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0001));
}
drivenby { // case 696
  x = (false@0b000@0b1101);
  y = (false@0b101@0b1100);
  // x + y
  //   +0.2031250) = (-1)^(0) * 2^(1 - 3) * 0.1101
  // +(+7.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1100
  // ----------------------------------------------
  //   +7.2031250) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // (-1)^(0) * 2^(5 - 3) * 11100 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1101));
}
drivenby { // case 697
  x = (true@0b100@0b1000);
  y = (false@0b000@0b1011);
  // x + y
  //   -3.0000000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // +(+0.1718750) = (-1)^(0) * 2^(1 - 3) * 0.1011
  // ----------------------------------------------
  //   -2.8281250) = (-1)^(1) * 2^(4 - 3) * 1.0111
  // (-1)^(1) * 2^(4 - 3) * 10110 1 0  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0111));
}
drivenby { // case 698
  x = (false@0b101@0b1010);
  y = (false@0b010@0b1001);
  // x + y
  //   +6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // +(+0.7812500) = (-1)^(0) * 2^(2 - 3) * 1.1001
  // ----------------------------------------------
  //   +7.2812500) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // (-1)^(0) * 2^(5 - 3) * 11101 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1101));
}
drivenby { // case 699
  x = (false@0b010@0b0110);
  y = (true@0b011@0b0100);
  // x + y
  //   +0.6875000) = (-1)^(0) * 2^(2 - 3) * 1.0110
  // +(-1.2500000) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // ----------------------------------------------
  //   -0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // (-1)^(1) * 2^(2 - 3) * 10010 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0010));
}
drivenby { // case 700
  x = (false@0b101@0b0010);
  y = (true@0b011@0b0000);
  // x + y
  //   +4.5000000) = (-1)^(0) * 2^(5 - 3) * 1.0010
  // +(-1.0000000) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // ----------------------------------------------
  //   +3.5000000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // (-1)^(0) * 2^(4 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1100));
}
drivenby { // case 701
  x = (false@0b101@0b0001);
  y = (true@0b101@0b1100);
  // x + y
  //   +4.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0001
  // +(-7.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // ----------------------------------------------
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // (-1)^(1) * 2^(4 - 3) * 10110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0110));
}
drivenby { // case 702
  x = (true@0b011@0b0101);
  y = (true@0b101@0b0111);
  // x + y
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // +(-5.7500000) = (-1)^(1) * 2^(5 - 3) * 1.0111
  // ----------------------------------------------
  //   -7.0625000) = (-1)^(1) * 2^(5 - 3) * 1.1100
  // (-1)^(1) * 2^(5 - 3) * 11100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1100));
}
drivenby { // case 703
  x = (true@0b010@0b0010);
  y = (false@0b000@0b1100);
  // x + y
  //   -0.5625000) = (-1)^(1) * 2^(2 - 3) * 1.0010
  // +(+0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // ----------------------------------------------
  //   -0.3750000) = (-1)^(1) * 2^(1 - 3) * 1.1000
  // (-1)^(1) * 2^(1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1000));
}
drivenby { // case 704
  x = (true@0b000@0b1010);
  y = (true@0b001@0b0011);
  // x + y
  //   -0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // +(-0.2968750) = (-1)^(1) * 2^(1 - 3) * 1.0011
  // ----------------------------------------------
  //   -0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // (-1)^(1) * 2^(1 - 3) * 11101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1101));
}
drivenby { // case 705
  x = (false@0b101@0b0000);
  y = (false@0b100@0b0000);
  // x + y
  //   +4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // +(+2.0000000) = (-1)^(0) * 2^(4 - 3) * 1.0000
  // ----------------------------------------------
  //   +6.0000000) = (-1)^(0) * 2^(5 - 3) * 1.1000
  // (-1)^(0) * 2^(5 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1000));
}
drivenby { // case 706
  x = (false@0b001@0b0111);
  y = (true@0b000@0b0011);
  // x + y
  //   +0.3593750) = (-1)^(0) * 2^(1 - 3) * 1.0111
  // +(-0.0468750) = (-1)^(1) * 2^(1 - 3) * 0.0011
  // ----------------------------------------------
  //   +0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // (-1)^(0) * 2^(1 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b0100));
}
drivenby { // case 707
  x = (false@0b000@0b1000);
  y = (true@0b011@0b0111);
  // x + y
  //   +0.1250000) = (-1)^(0) * 2^(1 - 3) * 0.1000
  // +(-1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   -1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // (-1)^(1) * 2^(3 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0101));
}
drivenby { // case 708
  x = (false@0b101@0b1001);
  y = (false@0b101@0b1101);
  // x + y
  //   +6.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // +(+7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // ----------------------------------------------
  //   +13.5000000) = (-1)^(0) * 2^(6 - 3) * 1.1011
  // (-1)^(0) * 2^(6 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b1011));
}
drivenby { // case 709
  x = (true@0b100@0b1011);
  y = (true@0b001@0b0100);
  // x + y
  //   -3.3750000) = (-1)^(1) * 2^(4 - 3) * 1.1011
  // +(-0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   -3.6875000) = (-1)^(1) * 2^(4 - 3) * 1.1110
  // (-1)^(1) * 2^(4 - 3) * 11101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1110));
}
drivenby { // case 710
  x = (false@0b101@0b1010);
  y = (false@0b011@0b1010);
  // x + y
  //   +6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // +(+1.6250000) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // ----------------------------------------------
  //   +8.1250000) = (-1)^(0) * 2^(6 - 3) * 1.0000
  // (-1)^(0) * 2^(6 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0000));
}
drivenby { // case 711
  x = (false@0b100@0b1111);
  y = (false@0b011@0b0100);
  // x + y
  //   +3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // +(+1.2500000) = (-1)^(0) * 2^(3 - 3) * 1.0100
  // ----------------------------------------------
  //   +5.1250000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 712
  x = (true@0b001@0b0100);
  y = (true@0b010@0b0111);
  // x + y
  //   -0.3125000) = (-1)^(1) * 2^(1 - 3) * 1.0100
  // +(-0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   -1.0312500) = (-1)^(1) * 2^(3 - 3) * 1.0000
  // (-1)^(1) * 2^(3 - 3) * 10000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0000));
}
drivenby { // case 713
  x = (false@0b100@0b0100);
  y = (false@0b101@0b0101);
  // x + y
  //   +2.5000000) = (-1)^(0) * 2^(4 - 3) * 1.0100
  // +(+5.2500000) = (-1)^(0) * 2^(5 - 3) * 1.0101
  // ----------------------------------------------
  //   +7.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1111
  // (-1)^(0) * 2^(5 - 3) * 11111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1111));
}
drivenby { // case 714
  x = (true@0b000@0b1001);
  y = (true@0b001@0b0101);
  // x + y
  //   -0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // +(-0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // ----------------------------------------------
  //   -0.4687500) = (-1)^(1) * 2^(1 - 3) * 1.1110
  // (-1)^(1) * 2^(1 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b1110));
}
drivenby { // case 715
  x = (true@0b001@0b1110);
  y = (true@0b000@0b1001);
  // x + y
  //   -0.4687500) = (-1)^(1) * 2^(1 - 3) * 1.1110
  // +(-0.1406250) = (-1)^(1) * 2^(1 - 3) * 0.1001
  // ----------------------------------------------
  //   -0.6093750) = (-1)^(1) * 2^(2 - 3) * 1.0100
  // (-1)^(1) * 2^(2 - 3) * 10011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0100));
}
drivenby { // case 716
  x = (false@0b010@0b0000);
  y = (true@0b000@0b0100);
  // x + y
  //   +0.5000000) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // +(-0.0625000) = (-1)^(1) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   +0.4375000) = (-1)^(0) * 2^(1 - 3) * 1.1100
  // (-1)^(0) * 2^(1 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1100));
}
drivenby { // case 717
  x = (true@0b011@0b1011);
  y = (true@0b000@0b0100);
  // x + y
  //   -1.6875000) = (-1)^(1) * 2^(3 - 3) * 1.1011
  // +(-0.0625000) = (-1)^(1) * 2^(1 - 3) * 0.0100
  // ----------------------------------------------
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // (-1)^(1) * 2^(3 - 3) * 11100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1100));
}
drivenby { // case 718
  x = (true@0b011@0b1100);
  y = (true@0b011@0b0101);
  // x + y
  //   -1.7500000) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // +(-1.3125000) = (-1)^(1) * 2^(3 - 3) * 1.0101
  // ----------------------------------------------
  //   -3.0625000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // (-1)^(1) * 2^(4 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1000));
}
drivenby { // case 719
  x = (true@0b100@0b1101);
  y = (false@0b101@0b1011);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(+6.7500000) = (-1)^(0) * 2^(5 - 3) * 1.1011
  // ----------------------------------------------
  //   +3.1250000) = (-1)^(0) * 2^(4 - 3) * 1.1001
  // (-1)^(0) * 2^(4 - 3) * 11001 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1001));
}
drivenby { // case 720
  x = (true@0b101@0b0000);
  y = (false@0b010@0b1110);
  // x + y
  //   -4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // +(+0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // ----------------------------------------------
  //   -3.0625000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // (-1)^(1) * 2^(4 - 3) * 11000 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b1000));
}
drivenby { // case 721
  x = (false@0b010@0b0101);
  y = (false@0b010@0b1011);
  // x + y
  //   +0.6562500) = (-1)^(0) * 2^(2 - 3) * 1.0101
  // +(+0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // ----------------------------------------------
  //   +1.5000000) = (-1)^(0) * 2^(3 - 3) * 1.1000
  // (-1)^(0) * 2^(3 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1000));
}
drivenby { // case 722
  x = (true@0b011@0b1001);
  y = (false@0b101@0b1101);
  // x + y
  //   -1.5625000) = (-1)^(1) * 2^(3 - 3) * 1.1001
  // +(+7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // ----------------------------------------------
  //   +5.6875000) = (-1)^(0) * 2^(5 - 3) * 1.0111
  // (-1)^(0) * 2^(5 - 3) * 10110 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0111));
}
drivenby { // case 723
  x = (false@0b010@0b0000);
  y = (false@0b011@0b1011);
  // x + y
  //   +0.5000000) = (-1)^(0) * 2^(2 - 3) * 1.0000
  // +(+1.6875000) = (-1)^(0) * 2^(3 - 3) * 1.1011
  // ----------------------------------------------
  //   +2.1875000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // (-1)^(0) * 2^(4 - 3) * 10001 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b0010));
}
drivenby { // case 724
  x = (true@0b010@0b1100);
  y = (false@0b011@0b1101);
  // x + y
  //   -0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // +(+1.8125000) = (-1)^(0) * 2^(3 - 3) * 1.1101
  // ----------------------------------------------
  //   +0.9375000) = (-1)^(0) * 2^(2 - 3) * 1.1110
  // (-1)^(0) * 2^(2 - 3) * 11110 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1110));
}
drivenby { // case 725
  x = (true@0b000@0b1010);
  y = (false@0b100@0b1011);
  // x + y
  //   -0.1562500) = (-1)^(1) * 2^(1 - 3) * 0.1010
  // +(+3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // ----------------------------------------------
  //   +3.2187500) = (-1)^(0) * 2^(4 - 3) * 1.1010
  // (-1)^(0) * 2^(4 - 3) * 11001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1010));
}
drivenby { // case 726
  x = (false@0b010@0b1011);
  y = (true@0b100@0b0101);
  // x + y
  //   +0.8437500) = (-1)^(0) * 2^(2 - 3) * 1.1011
  // +(-2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // ----------------------------------------------
  //   -1.7812500) = (-1)^(1) * 2^(3 - 3) * 1.1100
  // (-1)^(1) * 2^(3 - 3) * 11100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1100));
}
drivenby { // case 727
  x = (true@0b010@0b1101);
  y = (false@0b100@0b0110);
  // x + y
  //   -0.9062500) = (-1)^(1) * 2^(2 - 3) * 1.1101
  // +(+2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // ----------------------------------------------
  //   +1.8437500) = (-1)^(0) * 2^(3 - 3) * 1.1110
  // (-1)^(0) * 2^(3 - 3) * 11101 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b1110));
}
drivenby { // case 728
  x = (true@0b100@0b1000);
  y = (false@0b010@0b0111);
  // x + y
  //   -3.0000000) = (-1)^(1) * 2^(4 - 3) * 1.1000
  // +(+0.7187500) = (-1)^(0) * 2^(2 - 3) * 1.0111
  // ----------------------------------------------
  //   -2.2812500) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // (-1)^(1) * 2^(4 - 3) * 10010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0010));
}
drivenby { // case 729
  x = (true@0b011@0b1010);
  y = (true@0b100@0b0011);
  // x + y
  //   -1.6250000) = (-1)^(1) * 2^(3 - 3) * 1.1010
  // +(-2.3750000) = (-1)^(1) * 2^(4 - 3) * 1.0011
  // ----------------------------------------------
  //   -4.0000000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(5 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 730
  x = (true@0b001@0b0111);
  y = (true@0b001@0b0110);
  // x + y
  //   -0.3593750) = (-1)^(1) * 2^(1 - 3) * 1.0111
  // +(-0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // ----------------------------------------------
  //   -0.7031250) = (-1)^(1) * 2^(2 - 3) * 1.0110
  // (-1)^(1) * 2^(2 - 3) * 10110 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b0110));
}
drivenby { // case 731
  x = (false@0b100@0b0000);
  y = (false@0b011@0b0111);
  // x + y
  //   +2.0000000) = (-1)^(0) * 2^(4 - 3) * 1.0000
  // +(+1.4375000) = (-1)^(0) * 2^(3 - 3) * 1.0111
  // ----------------------------------------------
  //   +3.4375000) = (-1)^(0) * 2^(4 - 3) * 1.1100
  // (-1)^(0) * 2^(4 - 3) * 11011 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1100));
}
drivenby { // case 732
  x = (true@0b010@0b0011);
  y = (false@0b010@0b1111);
  // x + y
  //   -0.5937500) = (-1)^(1) * 2^(2 - 3) * 1.0011
  // +(+0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   +0.3750000) = (-1)^(0) * 2^(1 - 3) * 1.1000
  // (-1)^(0) * 2^(1 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1000));
}
drivenby { // case 733
  x = (false@0b100@0b0110);
  y = (false@0b100@0b0010);
  // x + y
  //   +2.7500000) = (-1)^(0) * 2^(4 - 3) * 1.0110
  // +(+2.2500000) = (-1)^(0) * 2^(4 - 3) * 1.0010
  // ----------------------------------------------
  //   +5.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 734
  x = (false@0b101@0b1010);
  y = (false@0b011@0b1010);
  // x + y
  //   +6.5000000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // +(+1.6250000) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // ----------------------------------------------
  //   +8.1250000) = (-1)^(0) * 2^(6 - 3) * 1.0000
  // (-1)^(0) * 2^(6 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b110@0b0000));
}
drivenby { // case 735
  x = (true@0b100@0b1101);
  y = (false@0b011@0b0101);
  // x + y
  //   -3.6250000) = (-1)^(1) * 2^(4 - 3) * 1.1101
  // +(+1.3125000) = (-1)^(0) * 2^(3 - 3) * 1.0101
  // ----------------------------------------------
  //   -2.3125000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // (-1)^(1) * 2^(4 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0010));
}
drivenby { // case 736
  x = (false@0b100@0b1111);
  y = (true@0b010@0b0000);
  // x + y
  //   +3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // +(-0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // (-1)^(0) * 2^(4 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1011));
}
drivenby { // case 737
  x = (false@0b001@0b0101);
  y = (true@0b100@0b0101);
  // x + y
  //   +0.3281250) = (-1)^(0) * 2^(1 - 3) * 1.0101
  // +(-2.6250000) = (-1)^(1) * 2^(4 - 3) * 1.0101
  // ----------------------------------------------
  //   -2.2968750) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // (-1)^(1) * 2^(4 - 3) * 10010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0010));
}
drivenby { // case 738
  x = (false@0b100@0b1111);
  y = (false@0b011@0b0011);
  // x + y
  //   +3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // +(+1.1875000) = (-1)^(0) * 2^(3 - 3) * 1.0011
  // ----------------------------------------------
  //   +5.0625000) = (-1)^(0) * 2^(5 - 3) * 1.0100
  // (-1)^(0) * 2^(5 - 3) * 10100 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0100));
}
drivenby { // case 739
  x = (true@0b001@0b1101);
  y = (true@0b101@0b1000);
  // x + y
  //   -0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // +(-6.0000000) = (-1)^(1) * 2^(5 - 3) * 1.1000
  // ----------------------------------------------
  //   -6.4531250) = (-1)^(1) * 2^(5 - 3) * 1.1010
  // (-1)^(1) * 2^(5 - 3) * 11001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1010));
}
drivenby { // case 740
  x = (true@0b100@0b0010);
  y = (false@0b010@0b1111);
  // x + y
  //   -2.2500000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // +(+0.9687500) = (-1)^(0) * 2^(2 - 3) * 1.1111
  // ----------------------------------------------
  //   -1.2812500) = (-1)^(1) * 2^(3 - 3) * 1.0100
  // (-1)^(1) * 2^(3 - 3) * 10100 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0100));
}
drivenby { // case 741
  x = (true@0b101@0b1011);
  y = (false@0b100@0b0001);
  // x + y
  //   -6.7500000) = (-1)^(1) * 2^(5 - 3) * 1.1011
  // +(+2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // ----------------------------------------------
  //   -4.6250000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // (-1)^(1) * 2^(5 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0010));
}
drivenby { // case 742
  x = (true@0b010@0b0111);
  y = (false@0b101@0b1001);
  // x + y
  //   -0.7187500) = (-1)^(1) * 2^(2 - 3) * 1.0111
  // +(+6.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1001
  // ----------------------------------------------
  //   +5.5312500) = (-1)^(0) * 2^(5 - 3) * 1.0110
  // (-1)^(0) * 2^(5 - 3) * 10110 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b0110));
}
drivenby { // case 743
  x = (true@0b101@0b1101);
  y = (true@0b010@0b1100);
  // x + y
  //   -7.2500000) = (-1)^(1) * 2^(5 - 3) * 1.1101
  // +(-0.8750000) = (-1)^(1) * 2^(2 - 3) * 1.1100
  // ----------------------------------------------
  //   -8.1250000) = (-1)^(1) * 2^(6 - 3) * 1.0000
  // (-1)^(1) * 2^(6 - 3) * 10000 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b110@0b0000));
}
drivenby { // case 744
  x = (false@0b101@0b1101);
  y = (true@0b010@0b1010);
  // x + y
  //   +7.2500000) = (-1)^(0) * 2^(5 - 3) * 1.1101
  // +(-0.8125000) = (-1)^(1) * 2^(2 - 3) * 1.1010
  // ----------------------------------------------
  //   +6.4375000) = (-1)^(0) * 2^(5 - 3) * 1.1010
  // (-1)^(0) * 2^(5 - 3) * 11001 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b101@0b1010));
}
drivenby { // case 745
  x = (true@0b001@0b0110);
  y = (true@0b001@0b1001);
  // x + y
  //   -0.3437500) = (-1)^(1) * 2^(1 - 3) * 1.0110
  // +(-0.3906250) = (-1)^(1) * 2^(1 - 3) * 1.1001
  // ----------------------------------------------
  //   -0.7343750) = (-1)^(1) * 2^(2 - 3) * 1.1000
  // (-1)^(1) * 2^(2 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b010@0b1000));
}
drivenby { // case 746
  x = (true@0b011@0b1000);
  y = (false@0b001@0b0100);
  // x + y
  //   -1.5000000) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // +(+0.3125000) = (-1)^(0) * 2^(1 - 3) * 1.0100
  // ----------------------------------------------
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // (-1)^(1) * 2^(3 - 3) * 10011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0011));
}
drivenby { // case 747
  x = (false@0b010@0b0100);
  y = (true@0b000@0b1101);
  // x + y
  //   +0.6250000) = (-1)^(0) * 2^(2 - 3) * 1.0100
  // +(-0.2031250) = (-1)^(1) * 2^(1 - 3) * 0.1101
  // ----------------------------------------------
  //   +0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // (-1)^(0) * 2^(1 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b001@0b1011));
}
drivenby { // case 748
  x = (false@0b000@0b1100);
  y = (true@0b101@0b0010);
  // x + y
  //   +0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // +(-4.5000000) = (-1)^(1) * 2^(5 - 3) * 1.0010
  // ----------------------------------------------
  //   -4.3125000) = (-1)^(1) * 2^(5 - 3) * 1.0001
  // (-1)^(1) * 2^(5 - 3) * 10001 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0001));
}
drivenby { // case 749
  x = (false@0b001@0b1011);
  y = (true@0b001@0b1101);
  // x + y
  //   +0.4218750) = (-1)^(0) * 2^(1 - 3) * 1.1011
  // +(-0.4531250) = (-1)^(1) * 2^(1 - 3) * 1.1101
  // ----------------------------------------------
  //   -0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // (-1)^(1) * 2^(-2 - 3) * 10000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b000@0b0010));
}
drivenby { // case 750
  x = (false@0b010@0b0010);
  y = (false@0b000@0b1100);
  // x + y
  //   +0.5625000) = (-1)^(0) * 2^(2 - 3) * 1.0010
  // +(+0.1875000) = (-1)^(0) * 2^(1 - 3) * 0.1100
  // ----------------------------------------------
  //   +0.7500000) = (-1)^(0) * 2^(2 - 3) * 1.1000
  // (-1)^(0) * 2^(2 - 3) * 11000 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b010@0b1000));
}
drivenby { // case 751
  x = (true@0b011@0b0011);
  y = (true@0b011@0b0010);
  // x + y
  //   -1.1875000) = (-1)^(1) * 2^(3 - 3) * 1.0011
  // +(-1.1250000) = (-1)^(1) * 2^(3 - 3) * 1.0010
  // ----------------------------------------------
  //   -2.3125000) = (-1)^(1) * 2^(4 - 3) * 1.0010
  // (-1)^(1) * 2^(4 - 3) * 10010 1 0  (r=true, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b100@0b0010));
}
drivenby { // case 752
  x = (true@0b011@0b0111);
  y = (true@0b000@0b0010);
  // x + y
  //   -1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // +(-0.0312500) = (-1)^(1) * 2^(1 - 3) * 0.0010
  // ----------------------------------------------
  //   -1.4687500) = (-1)^(1) * 2^(3 - 3) * 1.1000
  // (-1)^(1) * 2^(3 - 3) * 10111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1000));
}
drivenby { // case 753
  x = (false@0b000@0b1001);
  y = (true@0b100@0b0000);
  // x + y
  //   +0.1406250) = (-1)^(0) * 2^(1 - 3) * 0.1001
  // +(-2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // ----------------------------------------------
  //   -1.8593750) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // (-1)^(1) * 2^(3 - 3) * 11101 1 1  (r=true, s=true --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b1110));
}
drivenby { // case 754
  x = (true@0b100@0b0000);
  y = (true@0b011@0b1111);
  // x + y
  //   -2.0000000) = (-1)^(1) * 2^(4 - 3) * 1.0000
  // +(-1.9375000) = (-1)^(1) * 2^(3 - 3) * 1.1111
  // ----------------------------------------------
  //   -3.9375000) = (-1)^(1) * 2^(5 - 3) * 1.0000
  // (-1)^(1) * 2^(4 - 3) * 11111 1 0  (r=true, s=false --> round up)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b0000));
}
drivenby { // case 755
  x = (false@0b001@0b0101);
  y = (true@0b010@0b0101);
  // x + y
  //   +0.3281250) = (-1)^(0) * 2^(1 - 3) * 1.0101
  // +(-0.6562500) = (-1)^(1) * 2^(2 - 3) * 1.0101
  // ----------------------------------------------
  //   -0.3281250) = (-1)^(1) * 2^(1 - 3) * 1.0101
  // (-1)^(1) * 2^(1 - 3) * 10101 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b001@0b0101));
}
drivenby { // case 756
  x = (true@0b011@0b1110);
  y = (false@0b001@0b1100);
  // x + y
  //   -1.8750000) = (-1)^(1) * 2^(3 - 3) * 1.1110
  // +(+0.4375000) = (-1)^(0) * 2^(1 - 3) * 1.1100
  // ----------------------------------------------
  //   -1.4375000) = (-1)^(1) * 2^(3 - 3) * 1.0111
  // (-1)^(1) * 2^(3 - 3) * 10111 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b011@0b0111));
}
drivenby { // case 757
  x = (false@0b100@0b1111);
  y = (true@0b010@0b0000);
  // x + y
  //   +3.8750000) = (-1)^(0) * 2^(4 - 3) * 1.1111
  // +(-0.5000000) = (-1)^(1) * 2^(2 - 3) * 1.0000
  // ----------------------------------------------
  //   +3.3750000) = (-1)^(0) * 2^(4 - 3) * 1.1011
  // (-1)^(0) * 2^(4 - 3) * 11011 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b100@0b1011));
}
drivenby { // case 758
  x = (true@0b100@0b0110);
  y = (false@0b101@0b0000);
  // x + y
  //   -2.7500000) = (-1)^(1) * 2^(4 - 3) * 1.0110
  // +(+4.0000000) = (-1)^(0) * 2^(5 - 3) * 1.0000
  // ----------------------------------------------
  //   +1.2500000) = (-1)^(0) * 2^(3 - 3) * 1.0100
  // (-1)^(0) * 2^(3 - 3) * 10100 0 0  (r=false, s=false --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(false@0b011@0b0100));
}
drivenby { // case 759
  x = (true@0b101@0b1010);
  y = (true@0b000@0b0001);
  // x + y
  //   -6.5000000) = (-1)^(1) * 2^(5 - 3) * 1.1010
  // +(-0.0156250) = (-1)^(1) * 2^(1 - 3) * 0.0001
  // ----------------------------------------------
  //   -6.5156250) = (-1)^(1) * 2^(5 - 3) * 1.1010
  // (-1)^(1) * 2^(5 - 3) * 11010 0 0  (r=false, s=true --> round down)
  immediate abort { await(false); } when (rdy);
  assert(z==(true@0b101@0b1010));
}
drivenby { // case 760
  x = (false@0b100@0b0001);
  y = (true@0b001@0b1111);
  // x + y
  //   +2.1250000) = (-1)^(0) * 2^(4 - 3) * 1.0001
  // +(-0.4843750) = (-1)^(1) * 2^(1 - 3) * 1.1111
  // ----------------------------------------------
  //   +1.6406250) = (-1)^(0) * 2^(3 - 3) * 1.1010
  // (-1)^(0) * 2^(3 - 3) * 11010 0 1  (r=false, s=true --> round down)
  immediate abort { await(false); }