docs: protected static final double longS390BitsToDouble(long doubleBits) throws IOException {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "longS390BitsToDouble", doubleBits);
  
      // Test the sign bit (0 = positive, 1 = negative)
      boolean positive = ((doubleBits & DOUBLE_SIGN_MASK) == 0);
  
      // Deal with zero straight away...
      if ((doubleBits & 0x7fffffffffffffffL) == 0) {
        // + or - 0.0
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "zero");
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "longS390BitsToDouble");
        if (positive) {
          return 0.0D;
        }
        else {
          return - (0.0D);
        }
      }
  
      long mantissa = doubleBits & S390_DOUBLE_MANTISSA_MASK;
      long exponent = doubleBits & S390_DOUBLE_EXPONENT_MASK;
  
      // move the exponent into the LSB
      exponent = exponent >> 56;
      // subtract the bias
      exponent = exponent - S390_DOUBLE_BIAS;
  
      // caculate the IEEE exponent
      long ieeeExponent = exponent * 4;
  
      // Normalise the mantissa
      long ieeeMantissa = mantissa;
      // IEEE mantissa starts three places right of S390 (+ implicit bit)
      ieeeMantissa = ieeeMantissa >> 3;
      // if this is the samllest possible exponent, then there is no implicit bit,
      // and so we need to shift an extra bit
      if (ieeeExponent <= - (DOUBLE_BIAS)) {
        ieeeMantissa = ieeeMantissa >> 1;
        // now increase the exponent until it reaches -DOUBLE_BIAS, shifting
        // right one place at each stage to compensate
        while (ieeeExponent < - (DOUBLE_BIAS)) {
          ieeeExponent = ieeeExponent + 1;
          ieeeMantissa = ieeeMantissa >> 1;
        }
      }
  
      // complete the normalisation for exponents > -DOUBLE_BIAS
      while (  (ieeeMantissa != 0)
            && ((ieeeMantissa & DOUBLE_MANTISSA_MSB_MASK) == 0)
            && (ieeeExponent > - (DOUBLE_BIAS))
            ) {
        ieeeMantissa = ieeeMantissa << 1; // *2
        ieeeExponent = ieeeExponent - 1; // /2
      }
  
      // s390 has a wider range than IEEE, so deal with over and underflows
      if (ieeeExponent < -1045) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "longS390BitsToDouble",  "underflow");
        return 0.0F; // underflow
      }
      else if (ieeeExponent > 1024) {
        if (positive) {
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "overflow - returning +INFINITY");
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "longS390BitsToDouble", "+infinity");
          return (Double.MAX_VALUE * 2); // + infinity
        }
        else {
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "overflow - returning -INFINITY");
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "longS390BitsToDouble", "-infinity");
          return - (Double.MAX_VALUE * 2); // -infinity
        }
      }
  
      // Built the IEEE double
      long ieeeBits = 0;
      if (!positive) {
        ieeeBits = ieeeBits | DOUBLE_SIGN_MASK;
      }
  
      // add the bias to the exponent
      ieeeExponent = ieeeExponent + DOUBLE_BIAS;
      // move it to the IEEE exponent position
      ieeeExponent = ieeeExponent << 52;
      // add to the result
      ieeeBits = ieeeBits | ieeeExponent;
  
      // mask the top bit of the mantissa (implicit in IEEE)
      ieeeMantissa = ieeeMantissa & DOUBLE_MANTISSA_MASK;
      // add to the result
      ieeeBits = ieeeBits | ieeeMantissa;
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "IEEE bit pattern = " + Long.toString(ieeeBits, 16));
      double result = Double.longBitsToDouble(ieeeBits);
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "longS390BitsToDouble",  result);
      return result;
    }