diff --git a/src/qcbor_decode.c b/src/qcbor_decode.c
index a0e39bb..e75449c 100644
--- a/src/qcbor_decode.c
+++ b/src/qcbor_decode.c
@@ -1691,6 +1691,7 @@
       nReturn = QCBOR_ERR_BAD_EXP_AND_MANTISSA;
       goto Done;
    }
+   pDecodedItem->uNextNestLevel = mantissaItem.uNextNestLevel; // TODO: make sure this is right
 
 Done:
 
@@ -4408,65 +4409,75 @@
 
 
 #ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
-static void ProcessDecimalFraction(QCBORDecodeContext *pMe,
-                                   uint8_t             uTagRequirement,
+static QCBORError FooCheck(QCBORDecodeContext *pMe, TagSpecification TagSpec, QCBORItem *pItem)
+{
+   QCBORError uErr;
+   // Loops runs at most 1.5 times. Making it a loop saves object code.
+
+   while(1) {
+      uErr = CheckTagRequirement(TagSpec, pItem->uDataType);
+      if(uErr != QCBOR_SUCCESS) {
+         goto Done;
+      }
+
+      if(pItem->uDataType != QCBOR_TYPE_ARRAY) {
+         break; // Successful exit. Moving on to finish decoding.
+      }
+
+      // The item is an array, which means an undecoded
+      // mantissa and exponent, so decode it. It will then
+      // have a different type and exit the loop if.
+      uErr = QCBORDecode_MantissaAndExponent(pMe, pItem);
+      if(uErr != QCBOR_SUCCESS) {
+         goto Done;
+      }
+
+      // Second time around, the type must match.
+      TagSpec.uTagRequirement = QCBOR_TAG_REQUIREMENT_MATCH_TAG;
+   }
+Done:
+   return uErr;
+}
+
+static void ProcessMantissaAndExponent(QCBORDecodeContext *pMe,
+                                   TagSpecification             TagSpec,
                                    QCBORItem          *pItem,
                                    int64_t            *pnMantissa,
                                    int64_t            *pnExponent)
 {
    QCBORError uErr;
-   
-   if(pItem->uDataType == QCBOR_TYPE_ARRAY) {
 
-      if(uTagRequirement == QCBOR_TAG_REQUIREMENT_NO_TAG) {
-         pMe->uLastError = QCBOR_ERR_UNEXPECTED_TYPE;
-         return;
-      }
-      /* The decimal fraction was untagged so it shows up as an
-       array at this point. We are called to interpret it
-       as a decimal fraction, so do protocol decoding. If
-       it was tagged, iw would shouw up here with the
-       QCBOR_TYPE_DECIMAL_FRACTION or such. */
-      uErr = QCBORDecode_MantissaAndExponent(pMe, pItem);
-       if(uErr != QCBOR_SUCCESS) {
-          pMe->uLastError = (uint8_t)uErr;
-          return;
-       }
-    }
-   
-   if(uTagRequirement == QCBOR_TAG_REQUIREMENT_NO_TAG) {
-      pMe->uLastError = QCBOR_ERR_UNEXPECTED_TYPE;
-      return;
+   uErr = FooCheck(pMe, TagSpec, pItem);
+   if(uErr != QCBOR_SUCCESS) {
+      goto Done;
    }
     
     switch (pItem->uDataType) {
           
        case QCBOR_TYPE_DECIMAL_FRACTION:
+       case QCBOR_TYPE_BIGFLOAT:
           *pnMantissa = pItem->val.expAndMantissa.Mantissa.nInt;
           *pnExponent = pItem->val.expAndMantissa.nExponent;
           break;
           
        case QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM:
+       case QCBOR_TYPE_BIGFLOAT_POS_BIGNUM:
           *pnExponent = pItem->val.expAndMantissa.nExponent;
-          
           uErr = ConvertPositiveBigNumToSigned(pItem->val.expAndMantissa.Mantissa.bigNum, pnMantissa);
-          if(uErr != QCBOR_SUCCESS) {
-             pMe->uLastError = (uint8_t)uErr;
-          }
           break;
 
        case QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM:
+       case QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM:
           *pnExponent = pItem->val.expAndMantissa.nExponent;
-          
           uErr = ConvertNegativeBigNumToSigned(pItem->val.expAndMantissa.Mantissa.bigNum, pnMantissa);
-          if(uErr != QCBOR_SUCCESS) {
-             pMe->uLastError = (uint8_t)uErr;
-          }
           break;
           
        default:
-          pMe->uLastError = QCBOR_ERR_UNEXPECTED_TYPE;
+          uErr = QCBOR_ERR_UNEXPECTED_TYPE;
     }
+
+   Done:
+      pMe->uLastError = (uint8_t)uErr;
 }
 
 
@@ -4486,7 +4497,12 @@
       return;
    }
 
-   ProcessDecimalFraction(pMe, uTagRequirement, &Item, pnMantissa, pnExponent);
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM, QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
 }
 
 
@@ -4499,7 +4515,13 @@
    QCBORItem Item;
    
    QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
-   ProcessDecimalFraction(pMe, uTagRequirement, &Item, pnMantissa, pnExponent);
+
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM, QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
 }
 
 
@@ -4512,15 +4534,46 @@
    QCBORItem Item;
    
    QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
+
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM, QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
    
-   ProcessDecimalFraction(pMe, uTagRequirement, &Item, pnMantissa, pnExponent);
+   ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
 }
+
+
+void QCBORDecode_GetBigFloat(QCBORDecodeContext *pMe,
+                             uint8_t             uTagRequirement,
+                             int64_t             *pnMantissa,
+                             int64_t             *pnExponent)
+{
+   if(pMe->uLastError != QCBOR_SUCCESS) {
+      return;
+   }
+
+   QCBORItem Item;
+   QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
+   if(uError) {
+      pMe->uLastError = (uint8_t)uError;
+      return;
+   }
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM, QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponent(pMe, TagSpec, &Item, pnMantissa, pnExponent);
+}
+
 #endif /* ndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
 
 
 UsefulBufC ConvertIntToBigNum(uint64_t uInt, UsefulBuf Buffer)
 {
-   while(uInt & 0xff0000000000UL) {
+   while((uInt & 0xff00000000000000UL) == 0) {
       uInt = uInt << 8;
    };
    
@@ -4529,8 +4582,10 @@
    UsefulOutBuf_Init(&UOB, Buffer);
    
    while(uInt) {
-      UsefulOutBuf_AppendByte(&UOB, (uint8_t)((uInt & 0xff0000000000UL) >> 56));
+      const uint64_t xx = uInt & 0xff00000000000000UL;
+      UsefulOutBuf_AppendByte(&UOB, (uint8_t)((uInt & 0xff00000000000000UL) >> 56));
       uInt = uInt << 8;
+      (void)xx;
    }
    
    return UsefulOutBuf_OutUBuf(&UOB);
@@ -4539,32 +4594,19 @@
 
 #ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
 
-static void ProcessDecimalFractionBig(QCBORDecodeContext *pMe,
-                                      uint8_t             uTagRequirement,
-                                      QCBORItem          *pItem,
-                                      UsefulBuf           BufferForMantissa,
-                                      UsefulBufC         *pMantissa,
-                                      bool               *pbIsNegative,
-                                      int64_t            *pnExponent)
+static void ProcessMantissaAndExponentBig(QCBORDecodeContext *pMe,
+                                     TagSpecification    TagSpec,
+                                     QCBORItem          *pItem,
+                                     UsefulBuf           BufferForMantissa,
+                                     UsefulBufC         *pMantissa,
+                                     bool               *pbIsNegative,
+                                     int64_t            *pnExponent)
 {
+   QCBORError uErr;
 
-   const TagSpecification TagSpec = {uTagRequirement,
-      {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM, QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM},
-      {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
-   };
-
-   QCBORError uErr = CheckTagRequirement(TagSpec, pItem->uDataType);
+   uErr = FooCheck(pMe, TagSpec, pItem);
    if(uErr != QCBOR_SUCCESS) {
-      pMe->uLastError = (uint8_t)uErr;
-      return;
-   }
-
-   if(pItem->uDataType == QCBOR_TYPE_ARRAY) {
-      uErr = QCBORDecode_MantissaAndExponent(pMe, pItem);
-      if(uErr != QCBOR_SUCCESS) {
-         pMe->uLastError = (uint8_t)uErr;
-         return;
-      }
+      goto Done;
    }
 
    uint64_t uMantissa;
@@ -4572,6 +4614,7 @@
    switch (pItem->uDataType) {
 
       case QCBOR_TYPE_DECIMAL_FRACTION:
+      case QCBOR_TYPE_BIGFLOAT:
          if(pItem->val.expAndMantissa.Mantissa.nInt >= 0) {
             uMantissa = (uint64_t)pItem->val.expAndMantissa.Mantissa.nInt;
             *pbIsNegative = false;
@@ -4584,20 +4627,25 @@
          break;
 
       case QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM:
+      case QCBOR_TYPE_BIGFLOAT_POS_BIGNUM:
          *pnExponent = pItem->val.expAndMantissa.nExponent;
          *pMantissa = pItem->val.expAndMantissa.Mantissa.bigNum;
          *pbIsNegative = false;
          break;
 
       case QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM:
+      case QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM:
          *pnExponent = pItem->val.expAndMantissa.nExponent;
          *pMantissa = pItem->val.expAndMantissa.Mantissa.bigNum;
          *pbIsNegative = true;
          break;
 
       default:
-         pMe->uLastError = QCBOR_ERR_UNEXPECTED_TYPE;
+         uErr = QCBOR_ERR_UNEXPECTED_TYPE;
    }
+
+Done:
+   pMe->uLastError = (uint8_t)uErr;
 }
 
 
@@ -4620,7 +4668,12 @@
       return;
    }
 
-   ProcessDecimalFractionBig(pMe, uTagRequirement, &Item, MantissaBuffer, pMantissa, pbMantissaIsNegative, pnExponent);
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM, QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponentBig(pMe, TagSpec, &Item, MantissaBuffer, pMantissa, pbMantissaIsNegative, pnExponent);
 
 }
 
@@ -4639,11 +4692,92 @@
       return;
    }
 
-   ProcessDecimalFractionBig(pMe, uTagRequirement, &Item, BufferForMantissa, pMantissa, pbIsNegative, pnExponent);
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM, QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponentBig(pMe, TagSpec, &Item, BufferForMantissa, pMantissa, pbIsNegative, pnExponent);
 }
 
 
 void QCBORDecode_GetDecimalFractionBigInMapSZ(QCBORDecodeContext *pMe,
+                                              uint8_t             uTagRequirement,
+                                              const char         *szLabel,
+                                              UsefulBuf           BufferForMantissa,
+                                              UsefulBufC         *pMantissa,
+                                              bool               *pbIsNegative,
+                                              int64_t            *pnExponent)
+{
+   QCBORItem Item;
+
+   QCBORDecode_GetItemInMapSZ(pMe, szLabel, QCBOR_TYPE_ANY, &Item);
+   if(pMe->uLastError != QCBOR_SUCCESS) {
+      return;
+   }
+
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_DECIMAL_FRACTION, QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM, QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponentBig(pMe, TagSpec, &Item, BufferForMantissa, pMantissa, pbIsNegative, pnExponent);
+}
+
+
+void QCBORDecode_GetBigFloatBig(QCBORDecodeContext *pMe,
+                                uint8_t             uTagRequirement,
+                                UsefulBuf          MantissaBuffer,
+                                UsefulBufC         *pMantissa,
+                                bool               *pbMantissaIsNegative,
+                                int64_t            *pnExponent)
+{
+
+   if(pMe->uLastError != QCBOR_SUCCESS) {
+      return;
+   }
+
+   QCBORItem Item;
+   QCBORError uError = QCBORDecode_GetNext(pMe, &Item);
+   if(uError) {
+      pMe->uLastError = (uint8_t)uError;
+      return;
+   }
+
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM  , QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponentBig(pMe, TagSpec, &Item, MantissaBuffer, pMantissa, pbMantissaIsNegative, pnExponent);
+
+}
+
+void QCBORDecode_GetBigFloatBigInMapN(QCBORDecodeContext *pMe,
+                                             uint8_t             uTagRequirement,
+                                             int64_t             nLabel,
+                                             UsefulBuf           BufferForMantissa,
+                                             UsefulBufC         *pMantissa,
+                                             bool               *pbIsNegative,
+                                             int64_t            *pnExponent)
+{
+   QCBORItem Item;
+
+   QCBORDecode_GetItemInMapN(pMe, nLabel, QCBOR_TYPE_ANY, &Item);
+   if(pMe->uLastError != QCBOR_SUCCESS) {
+      return;
+   }
+
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM  , QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponentBig(pMe, TagSpec, &Item, BufferForMantissa, pMantissa, pbIsNegative, pnExponent);
+}
+
+
+void QCBORDecode_GetBigFloatBigInMapSZ(QCBORDecodeContext *pMe,
                                              uint8_t             uTagRequirement,
                                              const char         *szLabel,
                                              UsefulBuf           BufferForMantissa,
@@ -4658,7 +4792,12 @@
       return;
    }
 
-   ProcessDecimalFractionBig(pMe, uTagRequirement, &Item, BufferForMantissa, pMantissa, pbIsNegative, pnExponent);
+   const TagSpecification TagSpec = {uTagRequirement,
+        {QCBOR_TYPE_BIGFLOAT, QCBOR_TYPE_BIGFLOAT_POS_BIGNUM  , QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM},
+        {QCBOR_TYPE_ARRAY, QCBOR_TYPE_NONE, QCBOR_TYPE_NONE}
+     };
+
+   ProcessMantissaAndExponentBig(pMe, TagSpec, &Item, BufferForMantissa, pMantissa, pbIsNegative, pnExponent);
 }
 
 #endif /* ndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
diff --git a/test/qcbor_decode_tests.c b/test/qcbor_decode_tests.c
index 569b0bf..2620184 100644
--- a/test/qcbor_decode_tests.c
+++ b/test/qcbor_decode_tests.c
@@ -3652,7 +3652,7 @@
  */
 
 static const uint8_t spExpectedExponentsAndMantissas[] = {
-   0x87,
+   0x88,
    0xC4, 0x82, 0x20,
                0x03,
    0xC4, 0x82, 0x33,
@@ -3674,7 +3674,7 @@
 int32_t ExponentAndMantissaDecodeTests(void)
 {
    QCBORDecodeContext DC;
-   QCBORError         nCBORError;
+   QCBORError         uErr;
    QCBORItem          item;
 
    static const uint8_t spBigNumMantissa[] = {0x01, 0x02, 0x03, 0x04, 0x05,
@@ -3682,10 +3682,12 @@
    UsefulBufC BN = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNumMantissa);
 
 
-   QCBORDecode_Init(&DC, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedExponentsAndMantissas), QCBOR_DECODE_MODE_NORMAL);
+   QCBORDecode_Init(&DC,
+                    UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedExponentsAndMantissas),
+                    QCBOR_DECODE_MODE_NORMAL);
 
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
       return 1;
    }
 
@@ -3693,8 +3695,8 @@
       return 2;
    }
 
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
       return 3;
    }
 
@@ -3704,8 +3706,8 @@
       return 4;
    }
 
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
       return 5;
    }
 
@@ -3715,8 +3717,8 @@
       return 6;
    }
 
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
       return 7;
    }
 
@@ -3726,8 +3728,8 @@
       return 8;
    }
 
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
       return 9;
    }
 
@@ -3738,8 +3740,8 @@
    }
 
    // 5([-20, 4759477275222530853136]),
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
       return 11;
    }
    if(item.uDataType != QCBOR_TYPE_BIGFLOAT_POS_BIGNUM ||
@@ -3749,8 +3751,8 @@
    }
 
    // 5([-9223372036854775807, -4759477275222530853137])
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
       return 13;
    }
    if(item.uDataType != QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM ||
@@ -3760,26 +3762,30 @@
    }
 
    // 5([ 9223372036854775806, -4759477275222530853137])
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
-      return 13;
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
+      return 15;
    }
    if(item.uDataType != QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM ||
       item.val.expAndMantissa.nExponent != 9223372036854775806 ||
       UsefulBuf_Compare(item.val.expAndMantissa.Mantissa.bigNum, BN)) {
-      return 14;
+      return 16;
    }
 
-
    // 5([ 9223372036854775806,  9223372036854775806])]
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
-      return 15;
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
+      return 17;
    }
    if(item.uDataType != QCBOR_TYPE_BIGFLOAT ||
       item.val.expAndMantissa.nExponent != 9223372036854775806 ||
       item.val.expAndMantissa.Mantissa.nInt!= 9223372036854775806 ) {
-      return 16;
+      return 18;
+   }
+
+   uErr = QCBORDecode_Finish(&DC);
+   if(uErr != QCBOR_SUCCESS) {
+      return 18;
    }
 
    /* Now encode some stuff and then decode it */
@@ -3797,42 +3803,84 @@
 
 
    QCBORDecode_Init(&DC, Encoded, QCBOR_DECODE_MODE_NORMAL);
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
-      return 13;
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
+      return 100;
    }
 
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
-      return 13;
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
+      return 101;
    }
 
    if(item.uDataType != QCBOR_TYPE_DECIMAL_FRACTION ||
       item.val.expAndMantissa.nExponent != 1000 ||
       item.val.expAndMantissa.Mantissa.nInt != 999) {
-      return 15;
+      return 102;
    }
 
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
-      return 13;
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
+      return 103;
    }
 
    if(item.uDataType != QCBOR_TYPE_BIGFLOAT ||
       item.val.expAndMantissa.nExponent != INT32_MIN ||
       item.val.expAndMantissa.Mantissa.nInt != 100) {
-      return 15;
+      return 104;
    }
 
-   nCBORError = QCBORDecode_GetNext(&DC, &item);
-   if(nCBORError != QCBOR_SUCCESS) {
-      return 13;
+   uErr = QCBORDecode_GetNext(&DC, &item);
+   if(uErr != QCBOR_SUCCESS) {
+      return 105;
    }
 
    if(item.uDataType != QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM ||
       item.val.expAndMantissa.nExponent != INT32_MAX ||
       UsefulBuf_Compare(item.val.expAndMantissa.Mantissa.bigNum, BN)) {
-      return 12;
+      return 106;
+   }
+
+
+   int64_t                   nExp, nMant;
+   UsefulBuf_MAKE_STACK_UB(  MantBuf, 20);
+   UsefulBufC                Mant;
+   bool                      bIsNeg;
+
+   QCBORDecode_Init(&DC,
+                    UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedExponentsAndMantissas),
+                    QCBOR_DECODE_MODE_NORMAL);
+   QCBORDecode_EnterArray(&DC);
+
+   // 4([-1, 3]),
+   QCBORDecode_GetDecimalFraction(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &nExp, &nMant);
+
+   // 4([-20,                   4759477275222530853136]),
+   QCBORDecode_GetDecimalFractionBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
+
+   // 4([9223372036854775807,  -4759477275222530853137]),
+   QCBORDecode_GetDecimalFractionBig(&DC, QCBOR_TAG_REQUIREMENT_OPTIONAL_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
+
+   // 5([300, 100]),
+   QCBORDecode_GetBigFloat(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &nExp, &nMant);
+
+   // 5([-20,                   4759477275222530853136]),
+   QCBORDecode_GetBigFloatBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
+
+   // 5([-9223372036854775807, -4759477275222530853137])
+   QCBORDecode_GetBigFloatBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
+
+   // 5([ 9223372036854775806, -4759477275222530853137])
+   QCBORDecode_GetBigFloatBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
+
+   // 5([ 9223372036854775806,  9223372036854775806])]
+   QCBORDecode_GetBigFloatBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
+
+   QCBORDecode_ExitArray(&DC);
+
+   uErr = QCBORDecode_Finish(&DC);
+   if(uErr != QCBOR_SUCCESS) {
+      return 200;
    }
 
    return 0;