diff --git a/QCBOR.xcodeproj/project.pbxproj b/QCBOR.xcodeproj/project.pbxproj
index 7e0be2c..a266be7 100644
--- a/QCBOR.xcodeproj/project.pbxproj
+++ b/QCBOR.xcodeproj/project.pbxproj
@@ -118,6 +118,7 @@
 		E743D11B24DD4EF50017899F /* QCBOR_Disable_HW_Float */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = QCBOR_Disable_HW_Float; sourceTree = BUILT_PRODUCTS_DIR; };
 		E743D13124DE05CC0017899F /* QCBOR_Disable_Preferred_Float */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = QCBOR_Disable_Preferred_Float; sourceTree = BUILT_PRODUCTS_DIR; };
 		E743D132251014E60017899F /* Tagging.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = net.daringfireball.markdown; name = Tagging.md; path = doc/Tagging.md; sourceTree = "<group>"; };
+		E743D13325115A270017899F /* TRY SPIFFY DECODE.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = "TRY SPIFFY DECODE.md"; sourceTree = "<group>"; };
 		E74BF411245D6713002CE8E8 /* UsefulBuf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = UsefulBuf.h; path = inc/qcbor/UsefulBuf.h; sourceTree = "<group>"; };
 		E772022723B52C02006E966E /* QCBOR_Disable_Exp_Mantissa */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = QCBOR_Disable_Exp_Mantissa; sourceTree = BUILT_PRODUCTS_DIR; };
 		E776E07C214ADF7F00E67947 /* QCBOR */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = QCBOR; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -178,6 +179,7 @@
 			isa = PBXGroup;
 			children = (
 				E776E161214EE19C00E67947 /* README.md */,
+				E743D13325115A270017899F /* TRY SPIFFY DECODE.md */,
 				E743D132251014E60017899F /* Tagging.md */,
 				E776E096214AE0C700E67947 /* cmd_line_main.c */,
 				E776E092214AE07C00E67947 /* inc */,
diff --git a/TRY SPIFFY DECODE.md b/TRY SPIFFY DECODE.md
new file mode 100644
index 0000000..2f0c4a4
--- /dev/null
+++ b/TRY SPIFFY DECODE.md
@@ -0,0 +1,40 @@
+#  Try Spiffy Decode
+
+A major new version of QCBOR has Spiffy Decode which makes it much easier to 
+implement CBOR decoding.
+
+The decoding implementation of a protocol looks like the encoding implementation:
+
+     /* Encode */
+     QCBOREncode_Init(&EncodeCtx, Buffer);
+     QCBOREncode_OpenMap(&EncodeCtx);
+     QCBOREncode_AddTextToMap(&EncodeCtx, "Manufacturer", pE->Manufacturer);
+     QCBOREncode_AddInt64ToMap(&EncodeCtx, "Displacement", pE->uDisplacement);
+     QCBOREncode_AddInt64ToMap(&EncodeCtx, "Horsepower", pE->uHorsePower);
+     QCBOREncode_CloseMap(&EncodeCtx);
+     uErr = QCBOREncode_Finish(&EncodeCtx, &EncodedEngine);
+  
+     /* Decode */
+     QCBORDecode_Init(&DecodeCtx, EncodedEngine, QCBOR_DECODE_MODE_NORMAL);
+     QCBORDecode_EnterMap(&DecodeCtx);
+     QCBORDecode_GetTextStringInMapSZ(&DecodeCtx, "Manufacturer", &(pE->Manufacturer));
+     QCBORDecode_GetInt64InMapSZ(&DecodeCtx, "Displacement", &(pE->uDisplacement));
+     QCBORDecode_GetInt64InMapSZ(&DecodeCtx, "Horsepower", &(pE->uHorsePower));
+     QCBORDecode_ExitMap(&DecodeCtx);
+     uErr = QCBORDecode_Finish(&DecodeCtx);
+
+With the previous decoding API (which is still supported), the decode implementation 
+is 5-10 times longer.
+
+While the QCBOR library is larger, it reduces the object code needed to call it by a lot,
+so if you have to decode multiple maps, overall object code is likely to go down.
+
+While this new version is backwards compatible, it is a large change so it is not
+yet merged into the QCBOR master. It needs more testing before that happens.
+
+This new version is in SpiffyDecode branch so you have to explicitly go and get that branch.
+
+This version also improves tag handling a lot, adds duplicate map label detection and fixes
+some bugs with CBOR that is a combination of definite and indefinite lengths.
+
+
diff --git a/inc/qcbor/qcbor_common.h b/inc/qcbor/qcbor_common.h
index 400f023..5d5544f 100644
--- a/inc/qcbor/qcbor_common.h
+++ b/inc/qcbor/qcbor_common.h
@@ -246,7 +246,7 @@
     /** The buffer provided for the encoded output when doing encoding
         was too small and the encoded output will not fit. */
     QCBOR_ERR_BUFFER_TOO_SMALL = 1,
-   
+
     /** During encoding, an attempt to create simple value between 24
         and 31. */
     QCBOR_ERR_ENCODE_UNSUPPORTED = 2,
diff --git a/inc/qcbor/qcbor_encode.h b/inc/qcbor/qcbor_encode.h
index 9ac8dc2..0951bd5 100644
--- a/inc/qcbor/qcbor_encode.h
+++ b/inc/qcbor/qcbor_encode.h
@@ -648,7 +648,7 @@
 
  @param[in] pCtx  The encoding context to add the date to.
  @param[in] uTagRequirement  Either @ref QCBOR_ENCODE_AS_TAG or @ref QCBOR_ENCODE_AS_BORROWED.
- @param[in] date  Number of seconds since 1970-01-01T00:00Z in UTC time.
+ @param[in] nDate  Number of seconds since 1970-01-01T00:00Z in UTC time.
 
  As per RFC 7049 this is similar to UNIX/Linux/POSIX dates. This is
  the most compact way to specify a date and time in CBOR. Note that
@@ -675,24 +675,29 @@
  */
 static void QCBOREncode_AddTDateEpoch(QCBOREncodeContext *pCtx,
                                       uint8_t             uTagRequirement,
-                                      int64_t             date);
+                                      int64_t             nDate);
 
 static void QCBOREncode_AddTDateEpochToMapSZ(QCBOREncodeContext *pCtx,
                                              const char         *szLabel,
                                              uint8_t             uTagRequirement,
-                                             int64_t             date);
+                                             int64_t             nDate);
 
 static void QCBOREncode_AddTDateEpochToMapN(QCBOREncodeContext *pCtx,
                                             int64_t             nLabel,
                                             uint8_t             uTagRequirement,
-                                            int64_t             date);
+                                            int64_t             nDate);
 
 
-static void QCBOREncode_AddDateEpoch(QCBOREncodeContext *pCtx, int64_t date);
+static void QCBOREncode_AddDateEpoch(QCBOREncodeContext *pCtx,
+                                     int64_t             nDate);
 
-static void QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pCtx, const char *szLabel, int64_t date);
+static void QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pCtx,
+                                          const char         *szLabel,
+                                          int64_t             nDate);
 
-static void QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, int64_t date);
+static void QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pCtx,
+                                           int64_t             nLabel,
+                                           int64_t             nDate);
 
 
 /**
@@ -784,11 +789,16 @@
                                                  UsefulBufC          Bytes);
 
 
-static void QCBOREncode_AddPositiveBignum(QCBOREncodeContext *pCtx, UsefulBufC Bytes);
+static void QCBOREncode_AddPositiveBignum(QCBOREncodeContext *pCtx,
+                                          UsefulBufC          Bytes);
 
-static void QCBOREncode_AddPositiveBignumToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
+static void QCBOREncode_AddPositiveBignumToMap(QCBOREncodeContext *pCtx,
+                                               const char         *szLabel,
+                                               UsefulBufC          Bytes);
 
-static void QCBOREncode_AddPositiveBignumToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Bytes);
+static void QCBOREncode_AddPositiveBignumToMapN(QCBOREncodeContext *pCtx,
+                                                int64_t             nLabel,
+                                                UsefulBufC          Bytes);
 
 
 /**
@@ -824,11 +834,16 @@
                                                  UsefulBufC          Bytes);
 
 
-static void QCBOREncode_AddNegativeBignum(QCBOREncodeContext *pCtx, UsefulBufC Bytes);
+static void QCBOREncode_AddNegativeBignum(QCBOREncodeContext *pCtx,
+                                          UsefulBufC          Bytes);
 
-static void QCBOREncode_AddNegativeBignumToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
+static void QCBOREncode_AddNegativeBignumToMap(QCBOREncodeContext *pCtx,
+                                               const char         *szLabel,
+                                               UsefulBufC          Bytes);
 
-static void QCBOREncode_AddNegativeBignumToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Bytes);
+static void QCBOREncode_AddNegativeBignumToMapN(QCBOREncodeContext *pCtx,
+                                                int64_t             nLabel,
+                                                UsefulBufC          Bytes);
 
 
 #ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
@@ -1109,11 +1124,16 @@
                                       UsefulBufC          URI);
 
 
-static void QCBOREncode_AddURI(QCBOREncodeContext *pCtx, UsefulBufC URI);
+static void QCBOREncode_AddURI(QCBOREncodeContext *pCtx,
+                               UsefulBufC          URI);
 
-static void QCBOREncode_AddURIToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC URI);
+static void QCBOREncode_AddURIToMap(QCBOREncodeContext *pCtx,
+                                    const char         *szLabel,
+                                    UsefulBufC          URI);
 
-static void QCBOREncode_AddURIToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC URI);
+static void QCBOREncode_AddURIToMapN(QCBOREncodeContext *pCtx,
+                                     int64_t             nLabel,
+                                     UsefulBufC          URI);
 
 
 /**
@@ -1144,11 +1164,16 @@
                                           UsefulBufC B64Text);
 
 
-static void QCBOREncode_AddB64Text(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
+static void QCBOREncode_AddB64Text(QCBOREncodeContext *pCtx,
+                                   UsefulBufC          B64Text);
 
-static void QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC B64Text);
+static void QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pCtx,
+                                        const char         *szLabel,
+                                        UsefulBufC          B64Text);
 
-static void QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC B64Text);
+static void QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pCtx,
+                                         int64_t             nLabel,
+                                         UsefulBufC          B64Text);
 
 
 
@@ -1180,11 +1205,16 @@
                                              UsefulBufC          B64Text);
 
 
-static void QCBOREncode_AddB64URLText(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
+static void QCBOREncode_AddB64URLText(QCBOREncodeContext *pCtx,
+                                      UsefulBufC          B64Text);
 
-static void QCBOREncode_AddB64URLTextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC B64Text);
+static void QCBOREncode_AddB64URLTextToMap(QCBOREncodeContext *pCtx,
+                                           const char         *szLabel,
+                                           UsefulBufC          B64Text);
 
-static void QCBOREncode_AddB64URLTextToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC B64Text);
+static void QCBOREncode_AddB64URLTextToMapN(QCBOREncodeContext *pCtx,
+                                            int64_t             nLabel,
+                                            UsefulBufC          B64Text);
 
 
 /**
@@ -1215,11 +1245,16 @@
                                         UsefulBufC          Regex);
 
 
-static void QCBOREncode_AddRegex(QCBOREncodeContext *pCtx, UsefulBufC Regex);
+static void QCBOREncode_AddRegex(QCBOREncodeContext *pCtx,
+                                 UsefulBufC          Regex);
 
-static void QCBOREncode_AddRegexToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Regex);
+static void QCBOREncode_AddRegexToMap(QCBOREncodeContext *pCtx,
+                                      const char         *szLabel,
+                                      UsefulBufC          Regex);
 
-static void QCBOREncode_AddRegexToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Regex);
+static void QCBOREncode_AddRegexToMapN(QCBOREncodeContext *pCtx,
+                                       int64_t             nLabel,
+                                       UsefulBufC          Regex);
 
 
 /**
@@ -1227,7 +1262,7 @@
 
  @param[in] pCtx      The encoding context to add the MIME data to.
  @param[in] uTagRequirement  Either @ref QCBOR_ENCODE_AS_TAG or @ref QCBOR_ENCODE_AS_BORROWED.
- @param[in] MIMEData  Pointer and length of the regular expression.
+ @param[in] MIMEData  Pointer and length of the MIME Data.
 
  The text content is in MIME format per [RFC 2045]
  (https://tools.ietf.org/html/rfc2045) including the headers. Note
@@ -1252,11 +1287,16 @@
                                            UsefulBufC          MIMEData);
 
 
-static void QCBOREncode_AddMIMEData(QCBOREncodeContext *pCtx, UsefulBufC MIMEData);
+static void QCBOREncode_AddMIMEData(QCBOREncodeContext *pCtx,
+                                    UsefulBufC          MIMEData);
 
-static void QCBOREncode_AddMIMEDataToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC MIMEData);
+static void QCBOREncode_AddMIMEDataToMap(QCBOREncodeContext *pCtx,
+                                         const char         *szLabel,
+                                         UsefulBufC          MIMEData);
 
-static void QCBOREncode_AddMIMEDataToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC MIMEData);
+static void QCBOREncode_AddMIMEDataToMapN(QCBOREncodeContext *pCtx,
+                                          int64_t             nLabel,
+                                          UsefulBufC          MIMEData);
 
 
 /**
@@ -1293,11 +1333,16 @@
                                              const char         *szDate);
 
 
-static void QCBOREncode_AddDateString(QCBOREncodeContext *pCtx, const char *szDate);
+static void QCBOREncode_AddDateString(QCBOREncodeContext *pCtx,
+                                      const char         *szDate);
 
-static void QCBOREncode_AddDateStringToMap(QCBOREncodeContext *pCtx, const char *szLabel, const char *szDate);
+static void QCBOREncode_AddDateStringToMap(QCBOREncodeContext *pCtx,
+                                           const char         *szLabel,
+                                           const char         *szDate);
 
-static void QCBOREncode_AddDateStringToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, const char *szDate);
+static void QCBOREncode_AddDateStringToMapN(QCBOREncodeContext *pCtx,
+                                            int64_t             nLabel,
+                                            const char         *szDate);
 
 /**
  @brief  Add a standard Boolean.
@@ -1733,10 +1778,9 @@
 
 
 
-/* ===========================================================================
- BEGINNING OF PRIVATE INLINE IMPLEMENTATION
-
- =========================================================================== */
+/* =========================================================================
+     BEGINNING OF PRIVATE INLINE IMPLEMENTATION
+   ========================================================================= */
 
 /**
  @brief Semi-private method to add a buffer full of bytes to encoded output
@@ -1839,11 +1883,19 @@
  @param[in] nMantissa        The @c int64_t mantissa if it is not a big number.
  @param[in] nExponent        The exponent.
 
- This adds a tagged array with two members, the mantissa and exponent. The
- mantissa can be either a big number or an @c int64_t.
+ This outputs either the @ref CBOR_TAG_DECIMAL_FRACTION or @ref
+ CBOR_TAG_BIGFLOAT tag. if @c uTag is @ref CBOR_TAG_INVALID64, then
+ this outputs the "borrowed" content format.
 
- If @c uTag is @ref CBOR_INVALID_TAG64, then only the mantissa and exponent
- content will be encoded. See  TODO: finish this.
+ The tag content output by this is an array with two members, the
+ exponent and then the mantissa. The mantissa can be either a big
+ number or an @c int64_t.
+
+ This implementation cannot output an exponent further from 0 than
+ INT64_MAX.
+
+ To output a mantissa that is bewteen INT64_MAX and UINT64_MAX from 0,
+ it must be as a big number.
 
  Typically, QCBOREncode_AddDecimalFraction(), QCBOREncode_AddBigFloat(),
  QCBOREncode_AddDecimalFractionBigNum() or QCBOREncode_AddBigFloatBigNum()
@@ -2022,46 +2074,46 @@
 
 
 static inline void
-QCBOREncode_AddTDateEpoch(QCBOREncodeContext *pMe, uint8_t uTag, int64_t date)
+QCBOREncode_AddTDateEpoch(QCBOREncodeContext *pMe, uint8_t uTag, int64_t nDate)
 {
    if(uTag == QCBOR_ENCODE_AS_TAG) {
       QCBOREncode_AddTag(pMe, CBOR_TAG_DATE_EPOCH);
    }
-   QCBOREncode_AddInt64(pMe, date);
+   QCBOREncode_AddInt64(pMe, nDate);
 }
 
 static inline void
-QCBOREncode_AddTDateEpochToMapSZ(QCBOREncodeContext *pMe, const char *szLabel, uint8_t uTag, int64_t date)
+QCBOREncode_AddTDateEpochToMapSZ(QCBOREncodeContext *pMe, const char *szLabel, uint8_t uTag, int64_t nDate)
 {
    QCBOREncode_AddSZString(pMe, szLabel);
-   QCBOREncode_AddTDateEpoch(pMe, uTag, date);
+   QCBOREncode_AddTDateEpoch(pMe, uTag, nDate);
 }
 
 static inline void
-QCBOREncode_AddTDateEpochToMapN(QCBOREncodeContext *pMe, int64_t nLabel, uint8_t uTag, int64_t date)
+QCBOREncode_AddTDateEpochToMapN(QCBOREncodeContext *pMe, int64_t nLabel, uint8_t uTag, int64_t nDate)
 {
    QCBOREncode_AddInt64(pMe, nLabel);
-   QCBOREncode_AddTDateEpoch(pMe, uTag, date);
+   QCBOREncode_AddTDateEpoch(pMe, uTag, nDate);
 }
 
 static inline void
-QCBOREncode_AddDateEpoch(QCBOREncodeContext *pMe, int64_t date)
+QCBOREncode_AddDateEpoch(QCBOREncodeContext *pMe, int64_t nDate)
 {
-   QCBOREncode_AddTDateEpoch(pMe, QCBOR_ENCODE_AS_TAG, date);
+   QCBOREncode_AddTDateEpoch(pMe, QCBOR_ENCODE_AS_TAG, nDate);
 }
 
 static inline void
-QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pMe, const char *szLabel, int64_t date)
+QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pMe, const char *szLabel, int64_t nDate)
 {
    QCBOREncode_AddSZString(pMe, szLabel);
-   QCBOREncode_AddDateEpoch(pMe, date);
+   QCBOREncode_AddDateEpoch(pMe, nDate);
 }
 
 static inline void
-QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pMe, int64_t nLabel, int64_t date)
+QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pMe, int64_t nLabel, int64_t nDate)
 {
    QCBOREncode_AddInt64(pMe, nLabel);
-   QCBOREncode_AddDateEpoch(pMe, date);
+   QCBOREncode_AddDateEpoch(pMe, nDate);
 }
 
 
@@ -2245,10 +2297,11 @@
 
 #ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
 
-static inline void QCBOREncode_AddTDecimalFraction(QCBOREncodeContext *pMe,
-                                                   uint8_t             uTagRequirement,
-                                                   int64_t             nMantissa,
-                                                   int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddTDecimalFraction(QCBOREncodeContext *pMe,
+                                uint8_t             uTagRequirement,
+                                int64_t             nMantissa,
+                                int64_t             nBase10Exponent)
 {
    uint64_t uTag;
    if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
@@ -2264,59 +2317,62 @@
                                       nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddTDecimalFractionToMapSZ(QCBOREncodeContext *pMe,
-                                                        const char         *szLabel,
-                                                        uint8_t             uTagRequirement,
-                                                        int64_t             nMantissa,
-                                                        int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddTDecimalFractionToMapSZ(QCBOREncodeContext *pMe,
+                                       const char         *szLabel,
+                                       uint8_t             uTagRequirement,
+                                       int64_t             nMantissa,
+                                       int64_t             nBase10Exponent)
 {
    QCBOREncode_AddSZString(pMe, szLabel);
    QCBOREncode_AddTDecimalFraction(pMe, uTagRequirement, nMantissa, nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddTDecimalFractionToMapN(QCBOREncodeContext *pMe,
-                                                         int64_t             nLabel,
-                                                         uint8_t             uTagRequirement,
-                                                         int64_t             nMantissa,
-                                                         int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddTDecimalFractionToMapN(QCBOREncodeContext *pMe,
+                                      int64_t             nLabel,
+                                      uint8_t             uTagRequirement,
+                                      int64_t             nMantissa,
+                                      int64_t             nBase10Exponent)
 {
    QCBOREncode_AddInt64(pMe, nLabel);
    QCBOREncode_AddTDecimalFraction(pMe, uTagRequirement, nMantissa, nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddDecimalFraction(QCBOREncodeContext *pMe,
-                                                  int64_t             nMantissa,
-                                                  int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddDecimalFraction(QCBOREncodeContext *pMe,
+                               int64_t             nMantissa,
+                               int64_t             nBase10Exponent)
 {
    QCBOREncode_AddTDecimalFraction(pMe, QCBOR_ENCODE_AS_TAG, nMantissa, nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddDecimalFractionToMap(QCBOREncodeContext *pMe,
-                                                       const char         *szLabel,
-                                                       int64_t             nMantissa,
-                                                       int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddDecimalFractionToMap(QCBOREncodeContext *pMe,
+                                    const char         *szLabel,
+                                    int64_t             nMantissa,
+                                    int64_t             nBase10Exponent)
 {
    QCBOREncode_AddTDecimalFractionToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, nMantissa, nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddDecimalFractionToMapN(QCBOREncodeContext *pMe,
-                                                        int64_t             nLabel,
-                                                        int64_t             nMantissa,
-                                                        int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddDecimalFractionToMapN(QCBOREncodeContext *pMe,
+                                     int64_t             nLabel,
+                                     int64_t             nMantissa,
+                                     int64_t             nBase10Exponent)
 {
    QCBOREncode_AddTDecimalFractionToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, nMantissa, nBase10Exponent);
 }
 
 
 
-
-
-
-static inline void QCBOREncode_AddTDecimalFractionBigNum(QCBOREncodeContext *pMe,
-                                                         uint8_t             uTagRequirement,
-                                                         UsefulBufC          Mantissa,
-                                                         bool                bIsNegative,
-                                                         int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddTDecimalFractionBigNum(QCBOREncodeContext *pMe,
+                                      uint8_t             uTagRequirement,
+                                      UsefulBufC          Mantissa,
+                                      bool                bIsNegative,
+                                      int64_t             nBase10Exponent)
 {
    uint64_t uTag;
    if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
@@ -2331,41 +2387,45 @@
                                       nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddTDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pMe,
-                                                              const char         *szLabel,
-                                                              uint8_t             uTagRequirement,
-                                                              UsefulBufC          Mantissa,
-                                                              bool                bIsNegative,
-                                                              int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddTDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pMe,
+                                             const char         *szLabel,
+                                             uint8_t             uTagRequirement,
+                                             UsefulBufC          Mantissa,
+                                             bool                bIsNegative,
+                                             int64_t             nBase10Exponent)
 {
    QCBOREncode_AddSZString(pMe, szLabel);
    QCBOREncode_AddTDecimalFractionBigNum(pMe, uTagRequirement, Mantissa, bIsNegative, nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddTDecimalFractionBigNumToMapN(QCBOREncodeContext *pMe,
-                                                               int64_t             nLabel,
-                                                               uint8_t             uTagRequirement,
-                                                               UsefulBufC          Mantissa,
-                                                               bool                bIsNegative,
-                                                               int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddTDecimalFractionBigNumToMapN(QCBOREncodeContext *pMe,
+                                            int64_t             nLabel,
+                                            uint8_t             uTagRequirement,
+                                            UsefulBufC          Mantissa,
+                                            bool                bIsNegative,
+                                            int64_t             nBase10Exponent)
 {
    QCBOREncode_AddInt64(pMe, nLabel);
    QCBOREncode_AddTDecimalFractionBigNum(pMe, uTagRequirement, Mantissa, bIsNegative, nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddDecimalFractionBigNum(QCBOREncodeContext *pMe,
-                                                        UsefulBufC          Mantissa,
-                                                        bool                bIsNegative,
-                                                        int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddDecimalFractionBigNum(QCBOREncodeContext *pMe,
+                                     UsefulBufC          Mantissa,
+                                     bool                bIsNegative,
+                                     int64_t             nBase10Exponent)
 {
    QCBOREncode_AddTDecimalFractionBigNum(pMe, QCBOR_ENCODE_AS_TAG, Mantissa, bIsNegative, nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pMe,
-                                                             const char         *szLabel,
-                                                             UsefulBufC          Mantissa,
-                                                             bool                bIsNegative,
-                                                             int64_t             nBase10Exponent)
+static inline void
+QCBOREncode_AddDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pMe,
+                                            const char         *szLabel,
+                                            UsefulBufC          Mantissa,
+                                            bool                bIsNegative,
+                                            int64_t             nBase10Exponent)
 {
    QCBOREncode_AddTDecimalFractionBigNumToMapSZ(pMe,
                                                 szLabel,
@@ -2375,23 +2435,30 @@
                                                 nBase10Exponent);
 }
 
-static inline void QCBOREncode_AddDecimalFractionBigNumToMapN(QCBOREncodeContext *pMe,
-                                                              int64_t             nLabel,
-                                                              UsefulBufC          Mantissa,
-                                                              bool                bIsNegative,
-                                                              int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddDecimalFractionBigNumToMapN(QCBOREncodeContext *pMe,
+                                           int64_t             nLabel,
+                                           UsefulBufC          Mantissa,
+                                           bool                bIsNegative,
+                                           int64_t             nBase2Exponent)
 {
-   QCBOREncode_AddTDecimalFractionBigNumToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, Mantissa, bIsNegative, nBase2Exponent);
+   QCBOREncode_AddTDecimalFractionBigNumToMapN(pMe,
+                                               nLabel,
+                                               QCBOR_ENCODE_AS_TAG,
+                                               Mantissa,
+                                               bIsNegative,
+                                               nBase2Exponent);
 }
 
 
 
 
 
-static inline void QCBOREncode_AddTBigFloat(QCBOREncodeContext *pMe,
-                                            uint8_t             uTagRequirement,
-                                            int64_t             nMantissa,
-                                            int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddTBigFloat(QCBOREncodeContext *pMe,
+                         uint8_t             uTagRequirement,
+                         int64_t             nMantissa,
+                         int64_t             nBase2Exponent)
 {
    uint64_t uTag;
    if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
@@ -2402,56 +2469,62 @@
    QCBOREncode_AddExponentAndMantissa(pMe, uTag, NULLUsefulBufC, false, nMantissa, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddTBigFloatToMapSZ(QCBOREncodeContext *pMe,
-                                                 const char         *szLabel,
-                                                 uint8_t             uTagRequirement,
-                                                 int64_t             nMantissa,
-                                                 int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddTBigFloatToMapSZ(QCBOREncodeContext *pMe,
+                                const char         *szLabel,
+                                uint8_t             uTagRequirement,
+                                int64_t             nMantissa,
+                                int64_t             nBase2Exponent)
 {
    QCBOREncode_AddSZString(pMe, szLabel);
    QCBOREncode_AddTBigFloat(pMe, uTagRequirement, nMantissa, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddTBigFloatToMapN(QCBOREncodeContext *pMe,
-                                                  int64_t             nLabel,
-                                                  uint8_t             uTagRequirement,
-                                                  int64_t             nMantissa,
-                                                  int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddTBigFloatToMapN(QCBOREncodeContext *pMe,
+                               int64_t             nLabel,
+                               uint8_t             uTagRequirement,
+                               int64_t             nMantissa,
+                               int64_t             nBase2Exponent)
 {
    QCBOREncode_AddInt64(pMe, nLabel);
    QCBOREncode_AddTBigFloat(pMe, uTagRequirement, nMantissa, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddBigFloat(QCBOREncodeContext *pMe,
-                                           int64_t             nMantissa,
-                                           int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddBigFloat(QCBOREncodeContext *pMe,
+                        int64_t             nMantissa,
+                        int64_t             nBase2Exponent)
 {
    QCBOREncode_AddTBigFloat(pMe, QCBOR_ENCODE_AS_TAG, nMantissa, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddBigFloatToMap(QCBOREncodeContext *pMe,
-                                                const char         *szLabel,
-                                                int64_t             nMantissa,
-                                                int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddBigFloatToMap(QCBOREncodeContext *pMe,
+                             const char         *szLabel,
+                             int64_t             nMantissa,
+                             int64_t             nBase2Exponent)
 {
    QCBOREncode_AddTBigFloatToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, nMantissa, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddBigFloatToMapN(QCBOREncodeContext *pMe,
-                                                 int64_t             nLabel,
-                                                 int64_t             nMantissa,
-                                                 int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddBigFloatToMapN(QCBOREncodeContext *pMe,
+                              int64_t             nLabel,
+                              int64_t             nMantissa,
+                              int64_t             nBase2Exponent)
 {
    QCBOREncode_AddTBigFloatToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, nMantissa, nBase2Exponent);
 }
 
 
 
-static inline void QCBOREncode_AddTBigFloatBigNum(QCBOREncodeContext *pMe,
-                                                  uint8_t             uTagRequirement,
-                                                  UsefulBufC          Mantissa,
-                                                  bool                bIsNegative,
-                                                  int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddTBigFloatBigNum(QCBOREncodeContext *pMe,
+                               uint8_t             uTagRequirement,
+                               UsefulBufC          Mantissa,
+                               bool                bIsNegative,
+                               int64_t             nBase2Exponent)
 {
    uint64_t uTag;
    if(uTagRequirement == QCBOR_ENCODE_AS_TAG) {
@@ -2462,51 +2535,56 @@
    QCBOREncode_AddExponentAndMantissa(pMe, uTag, Mantissa, bIsNegative, 0, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddTBigFloatBigNumToMapSZ(QCBOREncodeContext *pMe,
-                                                       const char         *szLabel,
-                                                       uint8_t             uTagRequirement,
-                                                       UsefulBufC          Mantissa,
-                                                       bool                bIsNegative,
-                                                       int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddTBigFloatBigNumToMapSZ(QCBOREncodeContext *pMe,
+                                      const char         *szLabel,
+                                      uint8_t             uTagRequirement,
+                                      UsefulBufC          Mantissa,
+                                      bool                bIsNegative,
+                                      int64_t             nBase2Exponent)
 {
    QCBOREncode_AddSZString(pMe, szLabel);
    QCBOREncode_AddTBigFloatBigNum(pMe, uTagRequirement, Mantissa, bIsNegative, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddTBigFloatBigNumToMapN(QCBOREncodeContext *pMe,
-                                                        int64_t             nLabel,
-                                                        uint8_t             uTagRequirement,
-                                                        UsefulBufC          Mantissa,
-                                                        bool                bIsNegative,
-                                                        int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddTBigFloatBigNumToMapN(QCBOREncodeContext *pMe,
+                                     int64_t             nLabel,
+                                     uint8_t             uTagRequirement,
+                                     UsefulBufC          Mantissa,
+                                     bool                bIsNegative,
+                                     int64_t             nBase2Exponent)
 {
    QCBOREncode_AddInt64(pMe, nLabel);
    QCBOREncode_AddTBigFloatBigNum(pMe, uTagRequirement, Mantissa, bIsNegative, nBase2Exponent);
 }
 
 
-static inline void QCBOREncode_AddBigFloatBigNum(QCBOREncodeContext *pMe,
-                                                 UsefulBufC          Mantissa,
-                                                 bool                bIsNegative,
-                                                 int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddBigFloatBigNum(QCBOREncodeContext *pMe,
+                              UsefulBufC          Mantissa,
+                              bool                bIsNegative,
+                              int64_t             nBase2Exponent)
 {
    QCBOREncode_AddTBigFloatBigNum(pMe, QCBOR_ENCODE_AS_TAG, Mantissa, bIsNegative, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddBigFloatBigNumToMap(QCBOREncodeContext *pMe,
-                                                      const char         *szLabel,
-                                                      UsefulBufC          Mantissa,
-                                                      bool                bIsNegative,
-                                                      int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddBigFloatBigNumToMap(QCBOREncodeContext *pMe,
+                                   const char         *szLabel,
+                                   UsefulBufC          Mantissa,
+                                   bool                bIsNegative,
+                                   int64_t             nBase2Exponent)
 {
    QCBOREncode_AddTBigFloatBigNumToMapSZ(pMe, szLabel, QCBOR_ENCODE_AS_TAG, Mantissa, bIsNegative, nBase2Exponent);
 }
 
-static inline void QCBOREncode_AddBigFloatBigNumToMapN(QCBOREncodeContext *pMe,
-                                                       int64_t             nLabel,
-                                                       UsefulBufC          Mantissa,
-                                                       bool                bIsNegative,
-                                                       int64_t             nBase2Exponent)
+static inline void
+QCBOREncode_AddBigFloatBigNumToMapN(QCBOREncodeContext *pMe,
+                                    int64_t             nLabel,
+                                    UsefulBufC          Mantissa,
+                                    bool                bIsNegative,
+                                    int64_t             nBase2Exponent)
 {
    QCBOREncode_AddTBigFloatBigNumToMapN(pMe, nLabel, QCBOR_ENCODE_AS_TAG, Mantissa, bIsNegative, nBase2Exponent);
 }
@@ -3050,10 +3128,9 @@
 }
 
 
-/* ===========================================================================
- END OF PRIVATE INLINE IMPLEMENTATION
-
- =========================================================================== */
+/* ========================================================================
+     END OF PRIVATE INLINE IMPLEMENTATION
+   ======================================================================== */
 
 #ifdef __cplusplus
 }
diff --git a/src/qcbor_encode.c b/src/qcbor_encode.c
index 053f1f6..2416662 100644
--- a/src/qcbor_encode.c
+++ b/src/qcbor_encode.c
@@ -633,6 +633,10 @@
  one of the inline wrappers will usually be called rather than this.
 
  See qcbor/qcbor_encode.h
+
+ Improvement: create another version of this that only
+ takes a big number mantissa and converts the output to
+ a type 0 or 1 integer when mantissa is small enough.
  */
 void QCBOREncode_AddExponentAndMantissa(QCBOREncodeContext *pMe,
                                         uint64_t            uTag,