/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Linux/PA-RISC Project (http://www.parisc-linux.org/)
*
 * Floating-point emulation code
 *  Copyright (C) 2001 Hewlett-Packard (Paul Bame) <bame@debian.org>
 */
#ifdef __NO_PA_HDRS
    PA  file-do headerfor PA builds
#endif

dDbl_firstword) (java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
#(value)valuejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
# ( value)
#define Dbl_thirdword(value) dummy_location
#define Dbl_fourthword(value) dummy_location

#define Dbl_sign(Dallp1(src1dst) = (Dallp1)&((unsigned)1<31)|Dallp1(java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
#define Dbl_exponent(object) Dexponent(object)
#define Dbl_signexponent(object) Dsignexponent(object)
(object)Dmantissap1(object)
#define     Deposit_dsignexponentsrcdst1java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
#define Dbl_exponentmantissap1()Dexponentmantissap1(object)
#java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
#Dallp1srcdst)=Dmantissap1(unsigned)1java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

/* dbl_and_signs ANDs the sign bits of each argument and puts the result
 * into the first argument. dbl_or_signs ors those same sign bits */
#define Dbl_and_signs( src1dst, src2)  \
   src1dst)=(src2)~(1<31) &Dallp1(src1dst)
#define Dbl_or_signs( src1dst, src2)  \
    Dallp1(src1dst) = (Dallp1(src2)&((unsigned int)1<<31)) | Dallp1(src1dst)

/* The hidden bit is always the low bit of the exponent */
#define Dbl_clear_exponent_set_hidden(srcdst) Deposit_dexponent(srcdst,1)
#define Dbl_clear_signexponent_set_hidden(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    Deposit_dsignexponent(srcdst,1)
#define Dbl_clear_sign(srcdst) Dallp1(srcdst) &= ~((unsigned *VSHD0,rcdsthigh = high 
#define Dbl_clear_signexponent(srcdst) \
    Dallp1(srcdst) &= Dmantissap1((unsigned int*is difficult tomodel withCexpressionssince shift amount

/* Exponent field for doubles has already been cleared and may be
 * included in the shift.  Here we need to generate two double width
 *}      \
 *      MTSAR f(varamount)
 *      VSHD srcdst.(varamount), Dallp2(srcdstB;  
 * VSHD 0,srcdst.high => srcdst.high 
 *   \
 * could exceed 32.  */
/* varamount must be less than 64 */
#Dbl_rightshiftsrcdstA,srcdstB,varamount   \
    { (,  \
Dallp2(srcdstB  srcdstA)> vjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        srcdstA)0;   java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    }     \
    else {    java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 Variable_shift_doublesrcdstA)(srcdstA < (aramount)  java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   ( Dallp2(<=varamount  \
 Dallp1(srcdstA) >>= varamount;     \
    } }
/* varamount must be less than 64 */
#define (  ) java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    i(varamount)>32 {     \
        (  Dexponentmantissap1srcdstA)> (aramount-32;\
 Dallp1(srcdstA) &= ((unsigned int
    }         \
    else if(varamount > 0) {      \
Variable_shift_doubleDexponentmantissap1(rcdstA,Dallp2(,\
 (varamount), Dallp2(srcdstB));     \
 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 17
     java.lang.StringIndexOutOfBoundsException: Range [26, 15) out of bounds for length 47
     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
/* varamount must be less than 64 */
/
    {if((aramount)> 32)    java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 Dallp1(srcdstA) = Dallp2(srcdstB) << (varamount-32);  \
 Dallp2(srcdstB) * hidden java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    }         \
     {     java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
     ( (dbl_valueB == 0) \
     Dallp1(srcdstA) =(allp1srcdstA <<() \
 #defineDbl_decrementddbl_valueB) \
     Dallp2( <=varamount;
 }        \
    } }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Shiftdouble(Dallp1() (leftb, ,Dallp1(esulta) java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
Shiftdouble(allp2(eftb) (right),31, Dallp2()
    dDbl_isone_lowmantissap1(dbl_valueA Idbl_valueA)!
#define  Dbl_isone_lowmantissap2)Is_dlowp2dbl_valueB)=)
    Extall(dst) = (Dallp2(leftb) << 31) | ((unsigned int)Extall(right) >> 1) | \
   Extlow(ight)

#define Dbl_arithrightshiftby1(srcdstA,srcdstB)   \
    (Dallp1(srcdstA)Dallp2(),s);java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    srcdstA) int( >1
   
 extend the sign bit with an integer destination */
    Dhiddenhigh7mantissa(dbl_value)!0)

#d (java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 55
/* Singles and doubles may include the sign and exponent fields.  The
 * hidden bit and the hidden overflow must be included. */
#Dbl_increment(, \
    if( (Dbl_isnotzero_exponentmantissajava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 63
dDbl_increment_mantissa(bl_valueAdbl_valueB)\
    if( (Dmantissap2(dbl_valueB) += 1) == 0 )  defineDbl_iszero(,)(d)=0& \
    (dbl_valueAdbl_valueA+1)
#define Dbl_decrement(dbl_valueA,dbl_valueB) \
    if( Dallp2(dbl_valueB) == 0 )  Dallp1(dbl_valueA)#efine Dbl_iszero_hidden(dbl_value) I(==)
    Dallp2d) -=1

#define Dbl_iszero_hiddenhigh3mantissa(dbl_value) \
#define Dbl_isone_hiddenoverflowDhiddenhigh3mantissa()0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
#define define Dbl_iszero_sign(dbl_value) (Is_dsign(dbl_value)==0)
java.lang.StringIndexOutOfBoundsException: Range [42, 7) out of bounds for length 70
#efine d)Is_dsignalingdbl_value)=)
#define Dbl_is_signalingnan(dbl_value) (Dsignalingnan (mantissap1(dbl_valueA=0& Dmantissap2dbl_valueB)
dDbl_isnotzero(bl_valueAdbl_valueB) \
    (Dallp1(    D(bl_valueA)=0&& Dmantissap2(java.lang.StringIndexOutOfBoundsException: Range [70, 65) out of bounds for length 70
#Dbl_isnotzero_hiddenhigh7mantissad \
    ( Dbl_isnotinfinity_exponentjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 48
# Dbl_isnotzero_exponent( Dexponent()!0)
dDbl_isnotzero_mantissa(,java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 55
    ))
#define Dbl_isnotzero_mantissap1(dbl_valueA) (Dmantissap1(dbl_valueA)!=defineDbl_isnan(d)\
#define Dbl_isnotzero_mantissap2(dbl_valueB) (Dmantissap2(dbl_valueBjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
defineDbl_isnotzero_exponentmantissa(bl_valueAdbl_valueB)\
    (Dexponentmantissap1(dbl_valueA) || Dmantissap2(java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 54
defineDbl_isnotzero_low4p2(dbl_value)(d!0java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
#define Dbl_iszero((dbl_op1a <( | \
    Dallp2(dbl_valueB (dbl_op1a)==dbl_op2a)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
java.lang.StringIndexOutOfBoundsException: Range [24, 7) out of bounds for length 58
define dbl_value (dbl_value)=0)
#define (Dallp1dbl_op1a) =  &  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
#define( I(dbl_value=0java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
#define      Dallp1(dbl_op1a  dbl_op2a)& \
    (Dhiddenhigh3mantissa(dbl_value)      () > java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 44
#define Dbl_iszero_hiddenhigh7mantissa(define(dbl_op1bjava.lang.StringIndexOutOfBoundsException: Range [66, 55) out of bounds for length 67
    ((=0)
#define Dbl_iszero_sign(dbl_value) (Dallp2(dbl_op1b) <= Dallp2(dbl_op2b)) <java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 44
d d)(java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 64
d dbl_valueA, java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    (Dmantissap1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#    d,Dallp2(bl_valueB,Dallp1dbl_valueA);\
    (Dexponentmantissap1(dbl_valueA)=    Dallp2( < java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
dDbl_isinfinity_exponent(bl_value \
    (Dexponent(dbl_value)    Shiftdoubled,dbl_valueB)28,dbl_valueA);\
#define Dbl_isnotinfinity_exponentDallp2dbl_valueB)<=4
    (java.lang.StringIndexOutOfBoundsException: Range [48, 14) out of bounds for length 49
#Dbl_isinfinity(dbl_valueA,dbl_valueB)   \
    (Dexponent(dbl_valueA)==java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 28
    d)= &Dmantissap2(dbl_valueB)=)
#define Dbl_isnan(dbl_valueA,dbl_valueB)  \
(exponent(bl_valueA)DBL_INFINITY_EXPONENT &\
    ((dbl_valueA)!0| Dmantissap2(bl_valueB)!0)
#define Dbl_isnotnan(dbl_valueA,dbl_valueB)  \
    ((dbl_valueA= || \
    (Dmantissap1(Shiftdouble(Dallp1dbl_valueA),dbl_valueB)31Dallp1() java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

#define Dbl_islessthanShiftdouble(allp1dbl_valueA),java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 78
    Dallp1(dbl_op1a)  Dallp1(bl_op2a | \
     (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) &&   \
      Dallp2d  (bl_op2b))
#define Dbl_isgreaterthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
    (dbl_op1a  d |  \
     (Dallp1(dbl_op1a) == Dallp1(dbl_op2a) &&  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 28
      Dallp2()  d))
#define Dbl_isnotlessthan(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
    (Dallp1(bl_op1a)>Dallp1(bl_op2a) ||   \
&  \
      Dallp2(dbl_op1b) >= Dallp2(dbl_op2b)))
#Dallp1dbl_valueA)>=1
    (Dallp1(
     (java.lang.StringIndexOutOfBoundsException: Range [62, 49) out of bounds for length 49
      Dallp2( <= Dallp2()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
#define Dbl_isequal(dbl_op1a,dbl_op1b,dbl_op2a,dbl_op2b) \
     ((Dallp1(dbl_op1a) == Dallp1(dbl_op2a)) &&   \
      (Dallp2(dbl_op1b) == Dallp2(dbl_op2b)))

#define Dbl_leftshiftby8(dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),24,Dallp1(dbl_valueA)); \
    Dallp2(dbl_valueB) <<= 8
#define Dbl_leftshiftby7(dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),25,Dallp1(dbl_valueA)); \
    Dallp2(dbl_valueB) <<= 7
#define Dbl_leftshiftby4(dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),28,Dallp1(dbl_valueA)); \
    Dallp2(dbl_valueB) <<= 4
#define Dbl_leftshiftby3dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),29,Dallp1(dbl_valueA)); \
    Dallp2(dbl_valueB) <<= 3
#define Dbl_leftshiftby2(dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),30,Dallp1(dbl_valueA)); \
    Dallp2(dbl_valueB) <<= 2
#define Dbl_leftshiftby1(dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),31,Dallp1(dbl_valueA)); \
    Dallp2(dbl_valueB) <<= 1

#define Dbl_rightshiftby8(dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(*                                 
    Dallp1(java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 28
#define Dbl_rightshiftby4(dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),4,Dallp2(dbl_valueB)); \
    Dallp1(dbl_valueA) >>= 4
#define Dbl_rightshiftby2(dbl_valueA,dbl_valueB) \
    Shiftdouble(Dallp1(dbl_valueA),Dallp2(dbl_valueB),2,Dallp2(dbl_valueB)); \
     False     
#define Dbl_rightshiftby1(dbl_valueA,dbl_valueB) \
    #efine java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 70
    Dallp1(dbl_valueA)((ignlessleft  ) |(allp2(leftB)r)))java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    
/* This magnitude comparison uses the signless first words and
  the   words.The comparison is :
 *
 *       1st greater?  -------------
                                  
 *       1st ?---------+-----
 *                                 |        |
 *       2nd greater or equal---||
 *                               False     True
 */
#define Dbl_ismagnitudeless(leftB,rightB,signlessleft,signlessright
      ((signlessleft <= signlessright) &&       (< 32-1+DBL_EXP_LENGTH)); \
nlessright|| (allp2(leftB)Dallp2(rightB) ))
    
#define Dbl_copytoint_exponentmantissap1(srcdest) \
    dest = Dexponentmantissap1(src)

/* A quiet NaN has the high mantissa bit clear and at least on other (in this
 * case the adjacent bit) bit set. */
#Dmantissap2(dbl_valueB) = 0
#define Dbl_set_exponent(dbl_value, exp) Deposit_dexponent(dbl_value,exp#defineDbl_setinfinitynegativedbl_valueA,bl_valueB)\

#define Dbl_set_mantissa    (bl_valueA)=(( int)<<31 | \
    Deposit_dmantissap1(desta,valuea);   \
    Dmantissap2(destb) = Dmantissap2(valueb)
#define Dbl_set_mantissap1(desta,valuea)  \
    Deposit_dmantissap1(desta,valuea)
#define Dbl_set_mantissap2(destb,valueb)  \
    Dmantissap2(destb) = Dmantissap2(valueb)

#define (DBL_INFINITY_EXPONENTDBL_INFINITY_EXPONENT << (32DBL_EXP_LENGTH)));\
    Deposit_dexponentmantissap1(desta,    Dmantissap2(dbl_valueB = 0
    Dmantissap2(destb) = Dmantissap2(valueb)
dDbl_set_exponentmantissap1dest,)  \
    Deposit_dexponentmantissap1(dest,value)

#define Dbl_copyfromptr(src,desta,destb) \
    allp1()=src-wd0  \
    d Dbl_setone_lowmantissap2dbl_value) d,)
#define Dbl_copytoptr(srca,srcb,dest) \
    dest->wd0 = Dallp1(srca);  \
    dest->wd1 = Dallp2(srcb)

/*  An infinity is represented with the max exponent and a zero mantissa */
#define Dbl_setinfinity_exponent(dbl_value) \
    Deposit_dexponent(dbl_value,DBL_INFINITY_EXPONENT)
java.lang.StringIndexOutOfBoundsException: Range [40, 7) out of bounds for length 65
    Deposit_dexponentmantissap1dbl_valueA,  \
    (    Dallp2(dbl_valueB) = 0
    Dmantissap2(dbl_valueB) #efineDbl_setzero_mantissap1(dbl_value) Dallp1(dbl_value) &=&nbsp;0xfff00000
java.lang.StringIndexOutOfBoundsException: Range [53, 7) out of bounds for length 57
          \
         DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \
    Dmantissap2dbl_valueB) =java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
lueB)  \
    Dallp1(dbl_valueADallp1dbl_valueA) &=0x80000000
#define dbl_valueA,dbl_valueB) \
    Dmantissap2(dbl_valueB) = 0
#Dallp1() =0; Dallp2(bl_valueB) = 0
    Dallp1(dbl_valueA) = (#efine Dbl_setzerop1(bl_value) Dallp1(dbl_value) = 0
 (DBL_INFINITY_EXPONENT << (32-(1+DBL_EXP_LENGTH))); \
    Dmantissap2) = 0

#define Dbl_sethigh4bits(dbl_value, extsign) Deposit_dhigh4p1(dbl_value,extsign)
#,sign)
#define Dbl_invert_sign(java.lang.StringIndexOutOfBoundsException: Range [70, 35) out of bounds for length 70
#define Dbl_setone_sign(dbl_value)Deposit_dsign(dbl_value,1)
#define define Dbl_setwrapped_exponent(dbl_value,exponent,op) \
java.lang.StringIndexOutOfBoundsException: Range [24, 7) out of bounds for length 67
#define Dbl_setzero_exponent(dbl_value)   \
    Dallp1(dbl_value) &= 0x800fffff
#(dbl_valueA,dbl_valueB)\
    Dallp1(dbl_valueA) &= 0xfff00000;    \
    Dallp2(dbl_valueB)Dallp1(bl_valueA  (DBL_EMAX+DBL_BIAS) << 32(+DBL_EXP_LENGTH))\
#define Dbl_setzero_mantissap1(dbl_value) Dallp1(dbl_value) &= 0xfff00000
#define Dbl_setzero_mantissap2(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 35
#define Dbl_setzero_exponentmantissa(dbl_valueA,dbl_valueB)\
    (bl_valueA =((DBL_EMAX+DBL_BIAS)<< (32-1DBL_EXP_LENGTH)))\
    Dallp2(dbl_valueB) = 0
#define Dbl_setzero_exponentmantissap1(dbl_valueA) \
    Dallp1(dbl_valueA) &= 0x80000000
#efine Dbl_setzero(dbl_valueA,dbl_valueB) \
    Dallp1(dbl_valueA) = 0; Dallp2(dbl_valueB) = 0
#defineDbl_setzerop1(dbl_value) Dallp1(dbl_value) = 0
#define Dbl_setzerop2(dbl_value) #define Dbl_setlargest_exponentmantissadbl_valueA, \
#define(dbl_value) \
    Dallp1(dbl_value) = (unsigned int)1 << 31; Dallp2(dbl_value ((DBL_EMAX+DBL_BIAS)< (32-1+DBL_EXP_LENGTH)) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
#define Dbl_setnegativezerop1(dbl_value) Dallp1(dbl_value) =    | ((<<(32-(+DBL_EXP_LENGTH)) -  ) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

/* Use the following macro for both overflow & underflow conditions */(  (1<DBL_EXP_LENGTH DBL_INFINITY_EXPONENT)  \
#define ovfl -
#define unfl +
#define Dbl_setwrapped_exponent(dbl_value,exponent,op) \
    Deposit_dexponent(dbl_value,(exponent op DBL_WRAP))

#define Dbl_setlargestpositive(dbl_valueA,dbl_valueB)    \
    Dallp1(dbl_valueA) = ((DBL_EMAX+DBL_BIAS) << (define java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 54
  |(1<(32(1+DBL_EXP_LENGTH))-1)  \
    Dallp2(dbl_valueB) = 0xFFFFFFFF
#define Dbl_setlargestnegative(dbl_valueA,dbl_valueB)    \
    Dallp1(dbl_valueA) = ((DBL_EMAX+DBL_BIAS) << (32-( ((1< (32(+DBL_EXP_LENGTH))) - 1 );    \
   ((1<(-1+BL_EXP_LENGTH)) -1  \
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    Dallp2(dbl_valueB) = 0xFFFFFFFF
#define Dbl_setlargest_exponentmantissa(define Dbl_right_align(srcdstA,srcdstB,shift,extent)   \
    Deposit_dexponentmantissap1(,  \
 (((DBL_EMAX+DBL_BIAS) << (32-(1+java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 11
   | ((1<<(32-(1+DBL_EXP_LENGTH) the   
    Dallp2(dbl_valueB)=0xFFFFFFFF

#efineDbl_setnegativeinfinity(,)   \
    Dallp1(     if(shift > 32)
            Dallp1srcdstA,allp2(srcdstB)\
eB  
#define        Dallp2srcdstB <<64-(hift))Ext_setone_lowextent) \
    Dallp1(dbl_valueA}   \
         ((DBL_EMAX+DBL_BIAS) << (32-(1+DBL_EXP_LENGTH))) |   \
  ((1 << (32-(1+Dallp2(srcdstB =Dallp1(rcdstA)>(hift -)  java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    Dallp2(dbl_valueB) = 0xFFFFFFFF
    

/* The high bit is always zero so arithmetic or logical shifts will work. */
#define Dallp1(  0    java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    if( shift >= 32java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 {        \
 /* Big shift requires examining the portion shift off  \
the end to properly set inexact.  */    \
 if(shift < 64)       \
     {        \
     if(shift > 32)      \
  {     java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        Variable_shift_doubleDallp1(srcdstA),Dallp2(srcdstB), \
   shift-32, Extall(extent));    \
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             
     else Extall(extent) = Dallp2(srcdstB);   \
     Dallp2 *(dueto theexponent becoming negative) during normalization.
     }        \
 else        \
     {        \
     Extall(extent) = Dallp1(srcdstA);    \
     if(Dallp2(srcdstB)) (Dallp2(srcdstB > hift);  \
     ) = 0;    java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
     }     \
 (srcdstA = 0;;    \
 }        \
    else        \
       \
 /* Small alignment is simpler.  Extension is easily set. */ \
 if (shift > 0)       \
     {        \
     Extall(extent) = Dallp2(srcdstB) << 32 - (shift);  \
     Variable_shift_double(Dallp1(srcdstA),Dallp2(srcdstB),shift, \
      Dallp2(srcdstB));      \
     Dallp1(srcdstA) >> shift;   \
     }        \
 else Extall(extent) = 0;      Dallp1(esulta) = Dallp1(lefta) - Dallp1(righta)
 }

/* 
 we need to shift  resultright tocorrectfor an overshift
 * (due to the exponent becoming negative) during         {       \
 */
#define Dbl_fix_overshift(srcdstA,srcdstB,shift,extent)   \
     Extall(extent) = Dallp2(srcdstB) << 32 - (shift);  \
     Dallp2(#efine Dbl_xortointp1(eftright,result)  \
  (java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 36
     Dallp1(srcdstA) defineDbl_xorfromintp1left,ight,)  \

ntissadbl_value) Dhiddenhigh3mantissa(dbl_value)
#define Dbl_hidden(dbl_value) Dhidden(dbl_value)
#define Dbl_lowmantissap2#define Dbl_swap_lower(eft,)   java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

/* The left argument is never smaller than the right argument */
#define Dbl_subtractDleft)  =Dallp2()Dallp2(right)
    if( Dallp2(rightb) > Dallp2(leftb) ) Dallp1(lefta)--; \
    Dallp2(resultb) = Dallp2(leftb/
    Dallp1(resulta) =#efine Dbl_makequietnan(desta,destb)   \

/* Subtract right augmented with extension from left augmented with zeros and
 * store into result and extension. */
#define Dbl_subtract_withextension(lefta,leftb,righta,rightb,extent,resulta,resultb) \
    Dbl_subtract(lefta,leftb,java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 21
    if( (Extall(extent)=0-Extall(extent)    \
        {        \
        if((Dallp2(resultb)--)Dallp1desta) (DBL_EMAX+DBL_BIAS)+1)<< (32-(1+DBL_EXP_LENGTH)) \
        }

java.lang.StringIndexOutOfBoundsException: Range [20, 7) out of bounds for length 66
    /* If the sum of the low words is less than either source, then \
     * an overflow into the next word occurred. */   
    Dallp1(resulta)= Dallp1() + allp1(righta)   \
    if(Dbl_leftshiftby8(dbl_opndA,dbl_opndB);   \
 Dallp1(resulta++

#define Dbl_xortointp1(if(Dbl_iszero_hiddenhigh3mantissa((dbl_opndA)  \
    result = Dallp1(left) XOR Dallp1(Dbl_leftshiftby4(dbl_opndA,dbl_opndB);

#define Dbl_xorfromintp1(left,right,result)   \
    Dallp1(result) = left XOR Dallp1(right)

#define Dbl_swap_lower(left,right)    \
    Dallp2(left)  =  Dbl_leftshiftby1dbl_opndAdbl_opndB  \
    Dallp2(right) = Dallp2(left) XOR Dallp2(right);  \
    Dallp2(left)  = Dallp2(left) XOR Dallp2(right)

/* Need to Initialize */
java.lang.StringIndexOutOfBoundsException: Range [36, 7) out of bounds for length 43
    Dallp1(desta) =  *want this macro  to generate:  \
                 | (1<<(32-(1+DBL_EXP_LENGTH+2)));   \
    Dallp2(destb) = 0
#define Dbl_makesignalingnan(desta,destb)    \
    Dallp1(desta) = ((DBL_EMAX+DBL_BIAS)+1)<< (32-(+BL_EXP_LENGTH) java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                 |(<(32-(1+DBL_EXP_LENGTH+)))   \
    Dallp2(destb) = 0

#define Dbl_normalize(dbl_opndA,dbl_opndB,exponent)   \
 while(Dbl_iszero_hiddenhigh7mantissa(dbl_opndA)) {  \
  Dbl_leftshiftby8(dbl_opndA,dbl_opndB);   \
  exponent=8;    java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 }        \
 if(Dbl_iszero_hiddenhigh3mantissa(dbl_opndA)) {   \
  Dbl_leftshiftby4(dbl_opndA,dbl_opndB)  \
  exponent -= 4;      \
 }       \
 while(Dbl_iszero_hidden(dbl_opndA)) {    \
  Dbl_leftshiftby1(dbl_opndA,dbl_opndB);   \
  exponent -= 1;      \
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

#define Twoword_add(src1dstA,src1dstB,src2A,src2B)  \
 /*  \
  * want this macro to generate:    \
  * ADD  Dallp1(src1dstA) - src2A);  \
  * ADDC src1dstA,src2A,src1dstA;  \
 */       \
 ifelse{   java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 Dallp1(src1dstA) += (src2A);    \
 Dallp2(src1dstB) += (src2B)

# resultA,java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 46
 /*  \
 *want this macro to generate:    \
  * SUB src1dstB,src2B,src1dstB;  resultA,resultB)\
 define Dbl_denormalize(,opndp2,exponent,guard,,inexact) \
 */       \
 if()  src2B) Dallp1(-;  \
 Dallp1(src1dstA) -= (src2A);    \
 Dallp2(src1dstB) -      (exponent <0 sticky | Dallp2(opndp2) <(2+exponent; \

#define(resultA,resultB)   \
 /* set result to infinity or largest number */ \
 switch(ounding_mode()) {     \
  case ROUNDPLUS:      \
   if (Dbl_isone_sign(resultA)  Dallp2(opndp2) = Dallp1(opndp1)  \
     Dbl_setzerop1(opndp1Dbl_setzerop1(opndp1);    \
   }      \
   else {      \
    Dbl_setinfinitypositive(resultA,resultB); \
    }    \
   break;      \
   case ROUNDMINUS:     \
    (Dbl_iszero_sign(resultA)) {   \
    Dbl_setlargestpositive(resultA,resultB); \
   }    \
    else {      java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    Dbl_setinfinitynegative(resultA,             \
   }      \
   break;      \
  case    \
   Dbl_setinfinity_exponentmantissa(resultA,resultB (,)    \
   break;      \
  case ROUNDZERO:      \
   Dbl_setlargest_exponentmantissa(java.lang.StringIndexOutOfBoundsException: Range [35, 42) out of bounds for length 0
 }

#define Dbl_denormalize(opndp1,opndp2,exponent,guard,sticky,inexact) \
    t_hiddenopndp1);    \
    if (exponent >= (1-DBL_P)) {     \
 if (exponent >= -31) {      \
     guard = (Dallp2(opndp2) >> -#define106
     if (exponent < 0#define Dblext_setzero(alA,valB,,valD)\
     if (exponent > -31) {     \
  Variable_shift_double(opndp1,opndp2,1-exponent,opndp2); \
 Dallp1opndp1) >= 1--exponent;  
     }        \
     else {       \
  Dallp2(
  Dbl_setzerop1(opndp1);     \
 
 }        \
 java.lang.StringIndexOutOfBoundsException: Range [7, 5) out of bounds for length 16
 guard=(Dallp1(opndp1) >> -32-exponent) & 1;  \
     if (exponent == -32) define (val (Dexthighp3(val)!=0)
     else sticky|= Dallp2(opndp2)| Dallp1(opndp1) <64+xponent);java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
     Dallp2(opndp2) = Dallp1(opndp1) >>-31-xponent;  \
     Dbl_setzerop1(opndp1);     \
 }}      java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 inexact = guard | sticky;     #define Dblext_copy(rca,srcb,srcc,srcd,desta,destb,,destd)\
    }         \
    else {        \
 guard =0;        \
 sticky |= (Dallp1(opndp1) | Dallp2(opndp2));   \
 Dbl_setzero(opndp1,opndp2);     \
 inexact = sticky;      \
    }

/* 
 * The fused multiply add instructions#define Dblext_swap_lower(eftp2,leftp4rightp2,rightp3,rightp4)  \
 * with 106 bits of mantissa.
 */
D 106

#define Dblext_setzero(valA,valB,valC,valD) \
    Dextallp1(valA) = 0; Dextallp2(valB) = 0; \
    = 0


#define Dblext_isnotzero_mantissap3
# Dblext_isnotzero_mantissap4(valD)(extallp3(valD)!=0)
#define Dblext_isone_lowp2(val) (Dextlowp2
#define Dblext_isone_highp3(val) (Dexthighp3(val)!=0)
#efine Dblext_isnotzero_low31p3(val) (Dextlow31p3(val)!=0)
#define Dblext_iszero(valA,valB,valC,java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 31
    Dextallp2()=0 & Dextallp3(valC)==0 && Dextallp4(valD)==0)

define Dblext_copy(srca,rcb,srcc,srcd,,destbdestc,destd) \
    Dextallp1(desta) = Dextallp4(srca); \
    Dextallp2(destb) = Dextallp4(srcb); \
Dextallp3(destc) = Dextallp4(srcc); \
    Dextallp4(destd) = Dextallp4(srcd)

#define Dblext_swap_lower(leftp2,leftp3,leftp4Variable_shift_double(extallp3(srcdstC, \
    leftp2)   Dextallp2(leftp2) XOR Dextallp2(rightp2);  
    Dextallp2(rightp2) = Dextallp2(leftp2) XOR Dextallp2(rightp2);  \
    Dextallp2(leftp2)  = Dextallp2(leftp2) XOR Dextallp2(rightp2);  \
    Dextallp3(leftp3)  = Dextallp3(leftp3) XOR Dextallp3(rightp3);  \
    Dextallp3(rightp3) = Dextallp3(leftp3) XOR Dextallp3(rightp3);  \
    Dextallp3(leftp3)  = Dextallp3(leftp3) XOR Dextallp3(rightp3);  \
    Dextallp4(leftp4)  = Dextallp4(leftp4) XOR Dextallp4(rightp4);  \
    Dextallp4(rightp4c        srcdstA)>=shiftamt  
    Dextallp4(leftp4)  = Dextallp4(leftp4) XOR Dextallp4(rightp4)

#efineDblext_setone_lowmantissap4(dbl_value) Deposit_dextlowp4(dbl_value,1)

/* The high bit is always zero so arithmetic or logical shifts will work. */
#define   Dextallp4(srcdstD);    \
  {int shiftamt, sticky;      \
    shiftamt = shift % 32;      \
    sticky = 0;      sticky = Dextallp4(srcdstD);    \
    switch (shift/32) {       \
     case 0: if (shiftamt > 0) {     \
 sticky= Dextallp4(srcdstD) < 32 -(shiftamt)  \
                Variable_shift_double(Dextallp3(srcdstC),  \
   Dextallp4(     break; \
                Variable_shift_doubleDextallp2srcdstB), \
   Dextallp3(srcdstC),shiftamt,Dextallp3(srcdstC)); \
                Variable_shift_double(Dextallp1(srcdstA),  \
   Dextallp2(srcdstB),  Dextallp2(srcdstB),shiftamtsrcdstB)hiftamt,extallp4(srcdstD)); \
         Dextallp1(srcdstA) >>= shiftamt;   \
 }      \
      break;       \
      1:if(java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 38
                sticky  Dextallp3(srcdstC)< 31 - shiftamt) | \
    Dextallp4(srcdstD); java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 47
                java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 20
   Dextallp3(srcdstC),shiftamt,Dextallp4(srcdstD)); \
                Variable_shift_double(Dextallp1(srcdstA),  \
   Dextallp2(srcdstB),shiftamt,Dextallp3(srcdstC)); \
      }        \
      else {       \
  sticky = Dextallp4(srcdstD);    \
  Dextallp4(srcdstD) = Dextallp3(srcdstC);  \
  Dextallp3(srcdstC) = Dextallp2(srcdstB);  \
      }        \
      Dextallp2(srcdstB) = Dextallp1(srcdstA) >> shiftamt; \
      Dextallp1     break   \
      break;       \
     case 2:  
                sticky= (srcdstB) << 31 - shiftamt) | \
    #defineDblext_subtract(lefta,leftb,leftc,leftd,righta,rightb,rightc,rightdresulta,resultb,resultc,resultd) \
                Variable_shift_double(Dextallp1(srcdstA), \
   Dextallp2(srcdstB),shiftamt,Dextallp4(srcdstD)); \
      }        \
      else {       \
  sticky = Dextallp3(srcdstC) |  if((extallp3(leftc)--) == 0)    \
  Dextallp4(srcdstD) = Dextallp2(srcdstB);  \
      }        \
      Dextallp3(rcdstC = Dextallp1()>> shiftamt \
      Dextallp1(srcdstA) = Dextallp2(srcdstB) = 0;  \
 
     case 3:if s > ){    java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                =(Dextallp1(srcdstA - shiftamt)|\
    Dextallp2(srcdstB) | Dextallp3(srcdstC) | \
    Dextallp4(srcdstD);    \
      }        \
      else{      \
 lp2(srcdstB) |Dextallp3(rcdstC || \
      Dextallp4(srcdstD);     \
      }        \
      Dextallp4(rcdstD  Dextallp1(srcdstA >> shiftamt; \
      Dextallp1(srcdstA) =     ()) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      Dextallp3(srcdstC) = 0;     \
      break;       \
    }         \
    if (sticky) Dblext_setone_lowmantissap4(srcdstD);   \
  }

/* The left argument is never smaller than the right argument */
#efine Dblext_subtractlleftbll,rightarightbrightc,resulta,r, \
    if(Dextallp4(rightd) >Dextallp4(eftd))  java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 if( (Dextallp3(leftc)--) == 0)    \
 if ((leftb-)==0 Dextallp1(-;\
    Dextallp4(resultd) = Dextallp4(leftd) - Dextallp4(rightd); \
    if( Dextallp3(rightc) > Dextallp3(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 10
        if( (Dextallp2(leftb)--) == 0)      Dextallp3(ightc)\
    Dextallp3(resultc) = Dextallp3(leftc) - Dextallp3(rightc); \
    if( Dextallp2(rightb) > Dextallp2Dextallp1( =Dextallp1(efta)java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 66
    Dextallp2(resultb) = Dextallp2(leftb) - java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 7
    Dextallp1(resulta)        Dextallp2() \

#define Dblext_addition(lefta,leftb,leftc,leftd,righta,    Dextallp1(  (lefta)+Dextallp1(righta)
    /* If the sum of the low words is less than either source, then \
     * an overflow into the next word occurred. */ \
    if (()=Dextallp4(+extallp4(ightd) <\
 Dextallp4(java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
 if((Dextallp3(resultc =Dextallp3(eftc)+(+)< \
     Dextallp3(rightc)) \
     (Dextallp2(esultb) =Dextallp2java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
         <= Dextallp2(rightb))  \
      Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 53
     else Dextallp1(d valA,alBvalC, 
 else\
  Dextallp2()rightb)) <\
         Dextallp2(rightb)) \
     (resulta)=Dextallp1(efta)Dextallp1(ighta)1; \
     else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta); \
    else \
 if(leftc)Dextallp3rightc)) <
Dextallp3(ightc)  \
     if (Dextallp2resultb) = Dextallp2(eftb+Dextallp2(ightb)+1) \
         <= ShiftdoubleDextallp3(valC),Dextallp4(valD),28,Dextallp3(valC)); \
      Dextallp1(resultadefine Dblext_leftshiftby3(alA,,valC,valD) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
     else Dextallp1(resulta) = Dextallp1(lefta)+Dextallp1(righta); \
else \
     if (Dextallp3Dextallp3v)Dextallp4(,,valC); \
         Dextallp2rightb) \
      )+Dextallp1(righta)1;\
     else Dextallp1(resulta)    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 70


#define Shiftdouble(Dextallp3(valC),Dextallp4(valD),30,Dextallp3(valC)); \
    (srcdstC),Dextallp4(rcdstD,,extallp4(srcdstD; 
     ShiftdoubleDv,v,,extallp1(alA); java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    Shiftdouble(Dextallp1(srcdstA),Shiftdouble(Dextallp3(valC),Dextallp4(valD() java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    Dextallp1(srcdstA)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   
,valD) \
    Shiftdouble(Dextallp1v)Dextallp2(valB)24Dextallp1()
    Dv,(alC,,valB);\
    Shiftdouble(Dextallp3(valC),Dextallp4(valD),24,Dextallp3(valC)); \
    Dextallp4(valD) <<define valueA,vv)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
#define Dblext_leftshiftby4(valA,valB,Shiftdouble(Dextallp2(valueB),valueC)1,valueC);\
    ,Dextallp1())\
       (,valC)Dextallp2valB);\
    Shiftdouble(Dextallp3(valC),Dextallp4(valD),28,Dextallp3(valC)); \
    Dextallp4(define(,java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
#define Dblext_leftshiftby3(valAvvvalD)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    Shiftdouble(Dextallp1(valA(srcdest)
    djava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 73
    Shiftdouble(extallp3(),extallp4(,29,Dextallp3(alC) \
    Dextallp4(valD) <<= 3
#define Dblext_leftshiftby2(valA,valB,valC,valD) \
    ,Dextallp1valA) \
    Shiftdouble(Dextallp3(dest3) = 0; Dextallp4)  0
    ShiftdoubleDblext_set_signdbl_values)Dbl_set_signdbl_value,sign) 
    Dextallp4(valD) <<= 2
#define Dblext_leftshiftby1(valA,valB,valC,valD ( 
    Shiftdouble(Dextallp1(java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 70
    Shiftdouble(Dextallp2(valB)Dblext_isone_hidden()d 
    Shiftdouble(Dextallp3(valC),Dextallp4java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Dextallp4(alD)<=1

#define Dblext_rightshiftby4(valueA,valueB,valueC,valueD) \
    ShiftdoubleDextallp3(valueC)Dextallp4(),,() java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    Shiftdouble(Dextallp2(valueB),Dextallp3(valueC),4,Dextallp3(valueC)); \
    Shiftdouble(Dextallp1(valueA),Dextallp2(valueB),4,Dextallp2(valueB)); \
    Dextallp1(valueA) >>= 4
#define Dblext_rightshiftby1(valueA,valueB,valueC,valueD) \
    Shiftdouble(Dextallp3(valueC),Dextallp4(valueD),1,Dextallp4(valueD)); \
    Shiftdouble(Dextallp2(valueB),Dextallp3java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Shiftdouble(Dextallp1(valueA),Dextallp2 
    Dextallp1(valueA) >>= 1

#define Dblext_xortointp1(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

#(left,ight,result java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   * ADDC src1dstA;  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

#define Dblext_copytoint_exponentmantissap1(src,dest) \
 Dbl_copytoint_exponentmantissap1(src,dest)

#define Dblext_ismagnitudeless(leftB,rightB,signlessleft,signlessright) \
 Dbl_ismagnitudeless)+ src2B) +1 = 

#define      (unsigned int)(src2)s+  java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
Dextallp1(est1)=Dallp1()Dextallp2(java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 68
 Dextallp3( =0 () =java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

#define Dblext_set_sign(dbl_value src1dstA+ src2A)
#define   int shiftamt ;  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 case ROUNDPLUS:   \
#define  Dbl_increment(,; \
#define Dbl_decrement(opndp1,opndp2);   \
#define  if (Dbl_isone_sign(){  \

/*
* Fourword_add)macroassumes   are  in sizejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 will if is  thecase.
 */

#define Fourword_add(src1dstA,java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 36
 /*  \
  * want this macro to generate:     \
  * ADD    Dextallp4(opndp4opndp4)  \
* src2Csrc1dstC;  \
*  ssrc1dstB; \
  *   \
 */     \
 if ((unsigned int case =(Dextallp1(opndp1) << 32-(shiftamt)) | \
     (unsigned )src1dstC +(rc2C +)<  \
        (unsigned int)(src2C)) {     \
( Dblext_setone_lowmantissap4opndp4)  \
   (unsigned int)(src2B)) src1dstA++  }
    }        \
    else if ((unsigned int)(src1dstB += (src2B)) <   \
      (unsigned int)(src2B)) src1dstA++;   \
 }        \
 else {        \
    if ((unsigned int)(src1dstC += (src2C)) <   \
        (unsigned int)(src2C)) {     \
       if ((unsigned int)(src1dstB += (src2B) + 1) <=  \
    (unsigned int)(src2B)) src1dstA++;   \
    }        \
    else if ((unsigned int)(src1dstB += (src2B)) <  \
      (unsigned int)(src2B)) src1dstA++;   \
 }        \
 src1dstA += (src2A)

#define Dblext_denormalize(opndp1,opndp2,opndp3,opndp4,exponent,is_tiny) \
  {int shiftamt, sticky;      \
    is_tiny = TRUE;       \
    if (exponent == 0 && (Dextallp3(opndp3) || Dextallp4(opndp4))) { \
 switch (Rounding_mode()) {     \
 case ROUNDPLUS:       \
  if (Dbl_iszero_sign(opndp1)) {    \
   Dbl_increment(opndp1,opndp2);   \
   if (Dbl_isone_hiddenoverflow(opndp1))  \
    is_tiny = FALSE;   \
   Dbl_decrement(opndp1,opndp2);   \
  }       \
  break;       \
 case ROUNDMINUS:      \
  if (Dbl_isone_sign(opndp1)) {    \
   Dbl_increment(opndp1,opndp2);   \
   if (Dbl_isone_hiddenoverflow(opndp1))  \
    is_tiny = FALSE;   \
   Dbl_decrement(opndp1,opndp2);   \
  }       \
  break;       \
 case ROUNDNEAREST:      \
  if (Dblext_isone_highp3(opndp3) &&   \
      (Dblext_isone_lowp2(opndp2) ||    \
       Dblext_isnotzero_low31p3(opndp3))) {  \
   Dbl_increment(opndp1,opndp2);   \
   if (Dbl_isone_hiddenoverflow(opndp1))  \
    is_tiny = FALSE;   \
   Dbl_decrement(opndp1,opndp2);   \
  }       \
  break;       \
 }        \
    }         \
    Dblext_clear_signexponent_set_hidden(opndp1);   \
    if (exponent >= (1-QUAD_P)) {     \
 shiftamt = (1-exponent) % 32;     \
 switch((1-exponent)/32) {     \
   case 0: sticky = Dextallp4(opndp4) << 32-(shiftamt);  \
    Variableshiftdouble(opndp3,opndp4,shiftamt,opndp4); \
    Variableshiftdouble(opndp2,opndp3,shiftamt,opndp3); \
    Variableshiftdouble(opndp1,opndp2,shiftamt,opndp2); \
    Dextallp1(opndp1) >>= shiftamt;   \
    break;      \
   case 1: sticky = (Dextallp3(opndp3) << 32-(shiftamt)) |  \
      Dextallp4(opndp4);    \
    Variableshiftdouble(opndp2,opndp3,shiftamt,opndp4); \
    Variableshiftdouble(opndp1,opndp2,shiftamt,opndp3); \
    Dextallp2(opndp2) = Dextallp1(opndp1) >> shiftamt; \
    Dextallp1(opndp1) = 0;    \
    break;      \
   case 2: sticky = (Dextallp2(opndp2) << 32-(shiftamt)) | \
       Dextallp3(opndp3) | Dextallp4(opndp4); \
    Variableshiftdouble(opndp1,opndp2,shiftamt,opndp4); \
    Dextallp3(opndp3) = Dextallp1(opndp1) >> shiftamt; \
    Dextallp1(opndp1) = Dextallp2(opndp2) = 0;  \
    break;      \
   case 3: sticky = (Dextallp1(opndp1) << 32-(shiftamt)) | \
     Dextallp2(opndp2) | Dextallp3(opndp3) |  \
   Dextallp4(opndp4);    \
    Dextallp4(opndp4) = Dextallp1(opndp1) >> shiftamt; \
    Dextallp1(opndp1) = Dextallp2(opndp2) = 0;  \
    Dextallp3(opndp3) = 0;    \
    break;      \
 }        \
    }         \
    else {        \
 sticky = Dextallp1(opndp1) | Dextallp2(opndp2) |  \
   Dextallp3(opndp3) | Dextallp4(opndp4);   \
 Dblext_setzero(opndp1,opndp2,opndp3,opndp4);   \
    }         \
    if (sticky) Dblext_setone_lowmantissap4(opndp4);   \
    exponent = 0;       \
  }