diff --git a/README.md b/README.md
index b4d777f..46a2168 100644
--- a/README.md
+++ b/README.md
@@ -88,9 +88,9 @@
      /* 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_AddTextToMapSZ(&EncodeCtx, "Manufacturer", pE->Manufacturer);
+     QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "Displacement", pE->uDisplacement);
+     QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "Horsepower", pE->uHorsePower);
      QCBOREncode_CloseMap(&EncodeCtx);
      uErr = QCBOREncode_Finish(&EncodeCtx, &EncodedEngine);
 
diff --git a/example.c b/example.c
index ed5d597..a6a0a13 100644
--- a/example.c
+++ b/example.c
@@ -162,14 +162,14 @@
     /* Proceed to output all the items, letting the internal error
      * tracking do its work */
     QCBOREncode_OpenMap(&EncodeCtx);
-    QCBOREncode_AddTextToMap(&EncodeCtx, "Manufacturer", pEngine->Manufacturer);
-    QCBOREncode_AddInt64ToMap(&EncodeCtx, "NumCylinders", pEngine->uNumCylinders);
-    QCBOREncode_AddInt64ToMap(&EncodeCtx, "Displacement", pEngine->uDisplacement);
-    QCBOREncode_AddInt64ToMap(&EncodeCtx, "Horsepower", pEngine->uHorsePower);
+    QCBOREncode_AddTextToMapSZ(&EncodeCtx, "Manufacturer", pEngine->Manufacturer);
+    QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "NumCylinders", pEngine->uNumCylinders);
+    QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "Displacement", pEngine->uDisplacement);
+    QCBOREncode_AddInt64ToMapSZ(&EncodeCtx, "Horsepower", pEngine->uHorsePower);
 #ifndef USEFULBUF_DISABLE_ALL_FLOAT
-    QCBOREncode_AddDoubleToMap(&EncodeCtx, "DesignedCompression", pEngine->dDesignedCompresion);
+    QCBOREncode_AddDoubleToMapSZ(&EncodeCtx, "DesignedCompression", pEngine->dDesignedCompresion);
 #endif /* USEFULBUF_DISABLE_ALL_FLOAT */
-    QCBOREncode_OpenArrayInMap(&EncodeCtx, "Cylinders");
+   QCBOREncode_OpenArrayInMapSZ(&EncodeCtx, "Cylinders");
 #ifndef USEFULBUF_DISABLE_ALL_FLOAT
     for(int64_t i = 0 ; i < pEngine->uNumCylinders; i++) {
         QCBOREncode_AddDouble(&EncodeCtx,
@@ -177,7 +177,7 @@
     }
 #endif /* USEFULBUF_DISABLE_ALL_FLOAT */
     QCBOREncode_CloseArray(&EncodeCtx);
-    QCBOREncode_AddBoolToMap(&EncodeCtx, "Turbo", pEngine->bTurboCharged);
+    QCBOREncode_AddBoolToMapSZ(&EncodeCtx, "Turbo", pEngine->bTurboCharged);
     QCBOREncode_CloseMap(&EncodeCtx);
 
     /* Get the pointer and length of the encoded output. If there was
diff --git a/inc/qcbor/qcbor_common.h b/inc/qcbor/qcbor_common.h
index 1ebfb7b..4208c53 100644
--- a/inc/qcbor/qcbor_common.h
+++ b/inc/qcbor/qcbor_common.h
@@ -30,7 +30,7 @@
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * ========================================================================= */
-
+//#define USEFULBUF_DISABLE_ALL_FLOAT
 
 #ifndef qcbor_common_h
 #define qcbor_common_h
@@ -173,17 +173,17 @@
 #define CBOR_TAG_ENC_AS_B16    23
 /** See QCBORDecode_EnterBstrWrapped()). */
 #define CBOR_TAG_CBOR          24
-/** See QCBOREncode_AddURI(). */
+/** See QCBOREncode_AddTURI(). */
 #define CBOR_TAG_URI           32
-/** See QCBOREncode_AddB64URLText(). */
+/** See QCBOREncode_AddTB64URLText(). */
 #define CBOR_TAG_B64URL        33
 /** See QCBOREncode_AddB64Text(). */
 #define CBOR_TAG_B64           34
-/** See QCBOREncode_AddRegex(). */
+/** See QCBOREncode_AddTRegex(). */
 #define CBOR_TAG_REGEX         35
 /** See QCBOREncode_AddMIMEData(). */
 #define CBOR_TAG_MIME          36
-/** See QCBOREncode_AddBinaryUUID(). */
+/** See QCBOREncode_AddTBinaryUUID(). */
 #define CBOR_TAG_BIN_UUID      37
 /** The data is a CBOR Web Token per [RFC 8392]
  *  (https://www.rfc-editor.org/rfc/rfc8392.html). No API is provided for this
diff --git a/inc/qcbor/qcbor_decode.h b/inc/qcbor/qcbor_decode.h
index 69e93e7..7df9094 100644
--- a/inc/qcbor/qcbor_decode.h
+++ b/inc/qcbor/qcbor_decode.h
@@ -270,32 +270,32 @@
 #define QCBOR_TYPE_UKNOWN_SIMPLE 13
 
 /** A decimal fraction made of decimal exponent and integer mantissa.
- *  See @ref expAndMantissa and QCBOREncode_AddDecimalFraction(). */
+ *  See @ref expAndMantissa and QCBOREncode_AddTDecimalFraction(). */
 #define QCBOR_TYPE_DECIMAL_FRACTION            14
 
 /** A decimal fraction made of decimal exponent and positive big
  *  number mantissa. See @ref expAndMantissa and
- *  QCBOREncode_AddDecimalFractionBigNum(). */
+ *  QCBOREncode_AddTDecimalFractionBigNum(). */
 #define QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM 15
 
 /** A decimal fraction made of decimal exponent and negative big
  *  number mantissa. See @ref expAndMantissa and
- *  QCBOREncode_AddDecimalFractionBigNum(). */
+ *  QCBOREncode_AddTDecimalFractionBigNum(). */
 #define QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM 16
 
 /** A floating-point number made of base-2 exponent and integer
  *  mantissa.  See @ref expAndMantissa and
- *  QCBOREncode_AddBigFloat(). */
+ *  QCBOREncode_AddTBigFloat(). */
 #define QCBOR_TYPE_BIGFLOAT                    17
 
 /** A floating-point number made of base-2 exponent and positive big
  *  number mantissa.  See @ref expAndMantissa and
- *  QCBOREncode_AddBigFloatBigNum(). */
+ *  QCBOREncode_AddTBigFloatBigNum(). */
 #define QCBOR_TYPE_BIGFLOAT_POS_BIGNUM         18
 
 /** A floating-point number made of base-2 exponent and negative big
  *  number mantissa.  See @ref expAndMantissa and
- *  QCBOREncode_AddBigFloatBigNum(). */
+ *  QCBOREncode_AddTBigFloatBigNum(). */
 #define QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM         19
 
 /** Type for the simple value false. */
diff --git a/inc/qcbor/qcbor_encode.h b/inc/qcbor/qcbor_encode.h
index 64ddf1e..27d1dd5 100644
--- a/inc/qcbor/qcbor_encode.h
+++ b/inc/qcbor/qcbor_encode.h
@@ -259,7 +259,7 @@
  * support should be adequate.
  *
  * For example, the registered epoch date tag is supported in encoding
- * by QCBOREncode_AddDateEpoch() and in decoding by @ref
+ * by QCBOREncode_AddTDateEpoch() and in decoding by @ref
  * QCBOR_TYPE_DATE_EPOCH and the @c epochDate member of @ref
  * QCBORItem. This is typical of the built-in tag support. There is an
  * API to encode data for it and a @c QCBOR_TYPE_XXX when it is decoded.
@@ -742,7 +742,7 @@
  *
  * For many of the common standard tags, a function to encode data
  * using it is provided and this is not needed. For example,
- * QCBOREncode_AddDateEpoch() already exists to output integers
+ * QCBOREncode_AddTDateEpoch() already exists to output integers
  * representing dates with the right tag.
  *
  * The tag is applied to the next data item added to the encoded
@@ -1077,9 +1077,9 @@
  * CBOR Preferred serialization of the integers is used, thus they
  * will be encoded in the smallest number of bytes possible.
  *
- * See also QCBOREncode_AddDecimalFractionBigNum() for a decimal
+ * See also QCBOREncode_AddTDecimalFractionBigNum() for a decimal
  * fraction with arbitrarily large precision and
- * QCBOREncode_AddBigFloat().
+ * QCBOREncode_AddTBigFloat().
  *
  * There is no representation of positive or negative infinity or NaN
  * (Not a Number). Use QCBOREncode_AddDouble() to encode them.
@@ -1117,8 +1117,8 @@
  * @param[in] bIsNegative      false if mantissa is positive, true if negative.
  * @param[in] nBase10Exponent  The exponent.
  *
- * This is the same as QCBOREncode_AddDecimalFraction() except the
- * mantissa is a big number (See QCBOREncode_AddPositiveBignum())
+ * This is the same as QCBOREncode_AddTDecimalFraction() except the
+ * mantissa is a big number (See QCBOREncode_AddTPositiveBignum())
  * allowing for arbitrarily large precision.
  *
  * See @ref expAndMantissa for decoded representation.
@@ -1164,7 +1164,7 @@
  * which can be 8, 16, 32 or 64 bits. With both the mantissa and
  * exponent 64 bits they can express more precision and a larger range
  * than an IEEE double floating-point number. See
- * QCBOREncode_AddBigFloatBigNum() for even more precision.
+ * QCBOREncode_AddTBigFloatBigNum() for even more precision.
  *
  * For example, 1.5 would be represented by a mantissa of 3 and an
  * exponent of -1.
@@ -1215,8 +1215,8 @@
  * @param[in] bIsNegative      false if mantissa is positive, true if negative.
  * @param[in] nBase2Exponent   The exponent.
  *
- * This is the same as QCBOREncode_AddBigFloat() except the mantissa
- * is a big number (See QCBOREncode_AddPositiveBignum()) allowing for
+ * This is the same as QCBOREncode_AddTBigFloat() except the mantissa
+ * is a big number (See QCBOREncode_AddTPositiveBignum()) allowing for
  * arbitrary precision.
  *
  * See @ref expAndMantissa for decoded representation.
@@ -1264,7 +1264,7 @@
  * A URI in a NULL-terminated string, @c szURI, can be easily added with
  * this code:
  *
- *      QCBOREncode_AddURI(pCtx, UsefulBuf_FromSZ(szURI));
+ *      QCBOREncode_AddTURI(pCtx, QCBOR_ENCODE_AS_TAG, UsefulBuf_FromSZ(szURI));
  */
 static void
 QCBOREncode_AddTURI(QCBOREncodeContext *pCtx,
@@ -1907,7 +1907,7 @@
  * This cancels QCBOREncode_BstrWrap() making the encoding as if it
  * were never called.
  *
- * WARNING: This does not work on QCBOREncode_BstrWrapInMap()
+ * WARNING: This does not work on QCBOREncode_BstrWrapInMapSZ()
  * or QCBOREncode_BstrWrapInMapN() and there is no error detection
  * of an attempt at their use.
  *
@@ -2199,108 +2199,127 @@
  *    They just have been replaced by something better.                      *
  * ========================================================================= */
 
+/* Use QCBOREncode_AddInt64ToMapSZ() instead */
 static void
 QCBOREncode_AddInt64ToMap(QCBOREncodeContext *pCtx, const char *szLabel, int64_t nNum);
 
+/* Use QCBOREncode_AddUInt64ToMapSZ() instead */
 static void
 QCBOREncode_AddUInt64ToMap(QCBOREncodeContext *pCtx, const char *szLabel, uint64_t uNum);
 
+/* Use QCBOREncode_AddTextToMapSZ() instead */
 static void
 QCBOREncode_AddTextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Text);
 
+/* Use QCBOREncode_AddSZStringToMapSZ() instead */
 static void
 QCBOREncode_AddSZStringToMap(QCBOREncodeContext *pCtx, const char *szLabel, const char *szString);
 
+#ifndef USEFULBUF_DISABLE_ALL_FLOAT
+/* Use QCBOREncode_AddDoubleToMapSZ() instead */
 static void
 QCBOREncode_AddDoubleToMap(QCBOREncodeContext *pCtx, const char *szLabel, double dNum);
 
+/* Use QCBOREncode_AddFloatToMapSZ() instead */
 static void
 QCBOREncode_AddFloatToMap(QCBOREncodeContext *pCtx, const char *szLabel, float fNum);
 
+/* Use QCBOREncode_AddDoubleNoPreferredToMapSZ() instead */
 static void
 QCBOREncode_AddDoubleNoPreferredToMap(QCBOREncodeContext *pCtx, const char *szLabel, double dNum);
 
+/* Use QCBOREncode_AddFloatNoPreferredToMapSZ() instead */
 static void
 QCBOREncode_AddFloatNoPreferredToMap(QCBOREncodeContext *pCtx, const char *szLabel, float fNum);
+#endif /* ! USEFULBUF_DISABLE_ALL_FLOAT */
 
+/* Use QCBOREncode_AddTDateEpoch() instead */
 static void
-QCBOREncode_AddDateEpoch(QCBOREncodeContext *pCtx,
-                         int64_t             nDate);
+QCBOREncode_AddDateEpoch(QCBOREncodeContext *pCtx, int64_t nDate);
 
+/* Use QCBOREncode_AddTDateEpochToMapSZ() instead */
 static void
-QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pCtx,
-                              const char         *szLabel,
-                              int64_t             nDate);
+QCBOREncode_AddDateEpochToMap(QCBOREncodeContext *pCtx, const char *szLabel, int64_t nDate);
 
+/* Use QCBOREncode_AddTDateEpochToMapN() instead */
 static void
-QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pCtx,
-                               int64_t             nLabel,
-                               int64_t             nDate);
+QCBOREncode_AddDateEpochToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, int64_t nDate);
 
+/* Use QCBOREncode_AddBytesToMapSZ() instead */
 static void
 QCBOREncode_AddBytesToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
 
+/* Use QCBOREncode_AddTBinaryUUID() instead */
 static void
 QCBOREncode_AddBinaryUUID(QCBOREncodeContext *pCtx, UsefulBufC Bytes);
 
+/* Use QCBOREncode_AddTBinaryUUIDToMapSZ() instead */
 static void
 QCBOREncode_AddBinaryUUIDToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Bytes);
 
+/* Use QCBOREncode_AddTBinaryUUIDToMapN() instead */
 static void
 QCBOREncode_AddBinaryUUIDToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC Bytes);
 
+/* Use QCBOREncode_AddTPositiveBignum() instead */
 static void
-QCBOREncode_AddPositiveBignum(QCBOREncodeContext *pCtx,
-                              UsefulBufC          BigNumber);
+QCBOREncode_AddPositiveBignum(QCBOREncodeContext *pCtx, UsefulBufC BigNumber);
 
+/* QCBOREncode_AddTPositiveBignumToMapSZ() instead */
 static void
 QCBOREncode_AddPositiveBignumToMap(QCBOREncodeContext *pCtx,
                                    const char         *szLabel,
                                    UsefulBufC          BigNumber);
 
+/* Use QCBOREncode_AddTPositiveBignumToMapN() instead */
 static void
 QCBOREncode_AddPositiveBignumToMapN(QCBOREncodeContext *pCtx,
                                     int64_t             nLabel,
                                     UsefulBufC          BigNumber);
 
+/* Use QCBOREncode_AddTNegativeBignum() instead */
 static void
-QCBOREncode_AddNegativeBignum(QCBOREncodeContext *pCtx,
-                              UsefulBufC          BigNumber);
+QCBOREncode_AddNegativeBignum(QCBOREncodeContext *pCtx, UsefulBufC BigNumber);
 
+/* Use QCBOREncode_AddTNegativeBignumToMapSZ() instead */
 static void
-QCBOREncode_AddNegativeBignumToMap(QCBOREncodeContext *pCtx,
-                                   const char         *szLabel,
-                                   UsefulBufC          BigNumber);
+QCBOREncode_AddNegativeBignumToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC BigNumber);
 
+/* Use QCBOREncode_AddTNegativeBignumToMapN() instead */
 static void
-QCBOREncode_AddNegativeBignumToMapN(QCBOREncodeContext *pCtx,
-                                    int64_t             nLabel,
-                                    UsefulBufC          BigNumber);
+QCBOREncode_AddNegativeBignumToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC BigNumber);
 
+
+#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
+
+/* Use QCBOREncode_AddTDecimalFraction() instead */
 static void
 QCBOREncode_AddDecimalFraction(QCBOREncodeContext *pCtx,
                                int64_t             nMantissa,
                                int64_t             nBase10Exponent);
 
+/* Use QCBOREncode_AddTDecimalFractionToMapSZ() instead */
 static void
 QCBOREncode_AddDecimalFractionToMap(QCBOREncodeContext *pCtx,
                                     const char         *szLabel,
                                     int64_t             nMantissa,
                                     int64_t             nBase10Exponent);
 
+/* Use QCBOREncode_AddTDecimalFractionToMapN() instead */
 static void
 QCBOREncode_AddDecimalFractionToMapN(QCBOREncodeContext *pCtx,
                                      int64_t             nLabel,
                                      int64_t             nMantissa,
                                      int64_t             nBase10Exponent);
 
-
+/* Use QCBOREncode_AddTDecimalFractionBigNum() instead */
 static void
 QCBOREncode_AddDecimalFractionBigNum(QCBOREncodeContext *pCtx,
                                      UsefulBufC          Mantissa,
                                      bool                bIsNegative,
                                      int64_t             nBase10Exponent);
 
+/* Use QCBOREncode_AddTDecimalFractionBigNumToMapSZ() instead */
 static void
 QCBOREncode_AddDecimalFractionBigNumToMapSZ(QCBOREncodeContext *pCtx,
                                             const char         *szLabel,
@@ -2308,6 +2327,7 @@
                                             bool                bIsNegative,
                                             int64_t             nBase10Exponent);
 
+/* Use QCBOREncode_AddTDecimalFractionBigNumToMapN() instead */
 static void
 QCBOREncode_AddDecimalFractionBigNumToMapN(QCBOREncodeContext *pCtx,
                                            int64_t             nLabel,
@@ -2315,29 +2335,34 @@
                                            bool                bIsNegative,
                                            int64_t             nBase10Exponent);
 
+/* Use QCBOREncode_AddTBigFloat() instead */
 static void
 QCBOREncode_AddBigFloat(QCBOREncodeContext *pCtx,
                         int64_t             nMantissa,
                         int64_t             nBase2Exponent);
 
+/* Use QCBOREncode_AddTBigFloatToMapSZ() instead */
 static void
 QCBOREncode_AddBigFloatToMap(QCBOREncodeContext *pCtx,
                              const char         *szLabel,
                              int64_t             nMantissa,
                              int64_t             nBase2Exponent);
 
+/* Use QCBOREncode_AddTBigFloatToMapN() instead */
 static void
 QCBOREncode_AddBigFloatToMapN(QCBOREncodeContext *pCtx,
                               int64_t             nLabel,
                               int64_t             nMantissa,
                               int64_t             nBase2Exponent);
 
+/* Use QCBOREncode_AddTBigFloatBigNum() instead */
 static void
 QCBOREncode_AddBigFloatBigNum(QCBOREncodeContext *pCtx,
                               UsefulBufC          Mantissa,
                               bool                bIsNegative,
                               int64_t             nBase2Exponent);
 
+/* Use QCBOREncode_AddTBigFloatBigNumToMapSZ() instead */
 static void
 QCBOREncode_AddBigFloatBigNumToMap(QCBOREncodeContext *pCtx,
                                    const char         *szLabel,
@@ -2345,128 +2370,144 @@
                                    bool                bIsNegative,
                                    int64_t             nBase2Exponent);
 
+/* Use QCBOREncode_AddTBigFloatBigNumToMapN() instead */
 static void
 QCBOREncode_AddBigFloatBigNumToMapN(QCBOREncodeContext *pCtx,
                                     int64_t             nLabel,
                                     UsefulBufC          Mantissa,
                                     bool                bIsNegative,
                                     int64_t             nBase2Exponent);
+#endif /* ! QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
 
+/* Use QCBOREncode_AddTURI() instead */
 static void
-QCBOREncode_AddURI(QCBOREncodeContext *pCtx,
-                   UsefulBufC          URI);
+QCBOREncode_AddURI(QCBOREncodeContext *pCtx, UsefulBufC URI);
 
+/* Use QCBOREncode_AddTURIToMapSZ() instead */
 static void
-QCBOREncode_AddURIToMap(QCBOREncodeContext *pCtx,
-                          const char         *szLabel,
-                          UsefulBufC          URI);
+QCBOREncode_AddURIToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC URI);
 
+/* Use QCBOREncode_AddTURIToMapN() instead */
 static void
-QCBOREncode_AddURIToMapN(QCBOREncodeContext *pCtx,
-                         int64_t             nLabel,
-                         UsefulBufC          URI);
+QCBOREncode_AddURIToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC URI);
 
+/* Use QCBOREncode_AddTB64Text() instead */
 static void
-QCBOREncode_AddB64Text(QCBOREncodeContext *pCtx,
-                       UsefulBufC          B64Text);
+QCBOREncode_AddB64Text(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
 
+/* Use QCBOREncode_AddTB64TextToMapSZ() instead */
 static void
-QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pCtx,
-                            const char         *szLabel,
-                            UsefulBufC          B64Text);
+QCBOREncode_AddB64TextToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC B64Text);
 
+/* Use QCBOREncode_AddTB64TextToMapN() instead */
 static void
-QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pCtx,
-                             int64_t             nLabel,
-                             UsefulBufC          B64Text);
+QCBOREncode_AddB64TextToMapN(QCBOREncodeContext *pCtx, int64_t nLabel, UsefulBufC B64Text);
 
+/* Use QCBOREncode_AddTB64URLText() instead */
 static void
-QCBOREncode_AddB64URLText(QCBOREncodeContext *pCtx,
-                          UsefulBufC          B64Text);
+QCBOREncode_AddB64URLText(QCBOREncodeContext *pCtx, UsefulBufC B64Text);
 
+/* Use QCBOREncode_AddTB64URLTextToMapSZ() instead */
 static void
 QCBOREncode_AddB64URLTextToMap(QCBOREncodeContext *pCtx,
                                const char         *szLabel,
                                UsefulBufC          B64Text);
 
+/* Use QCBOREncode_AddTB64URLTextToMapN() instead */
 static void
 QCBOREncode_AddB64URLTextToMapN(QCBOREncodeContext *pCtx,
                                 int64_t             nLabel,
                                 UsefulBufC          B64Text);
 
+/* Use QCBOREncode_AddTRegex() instead */
 static void
-QCBOREncode_AddRegex(QCBOREncodeContext *pCtx,
-                     UsefulBufC          Regex);
+QCBOREncode_AddRegex(QCBOREncodeContext *pCtx, UsefulBufC Regex);
 
+/* Use QCBOREncode_AddTRegexToMapSZ() instead */
 static void
 QCBOREncode_AddRegexToMap(QCBOREncodeContext *pCtx,
                           const char         *szLabel,
                           UsefulBufC          Regex);
 
+/* Use QCBOREncode_AddTRegexToMapN() instead */
 static void
 QCBOREncode_AddRegexToMapN(QCBOREncodeContext *pCtx,
                            int64_t             nLabel,
                            UsefulBufC          Regex);
 
+/* Use QCBOREncode_AddTMIMEData() instead */
 static void
-QCBOREncode_AddMIMEData(QCBOREncodeContext *pCtx,
-                        UsefulBufC          MIMEData);
+QCBOREncode_AddMIMEData(QCBOREncodeContext *pCtx, UsefulBufC MIMEData);
 
+/* Use QCBOREncode_AddTMIMEDataToMapSZ() instead */
 static void
 QCBOREncode_AddMIMEDataToMap(QCBOREncodeContext *pCtx,
                              const char         *szLabel,
                              UsefulBufC          MIMEData);
 
+/* Use QCBOREncode_AddTMIMEDataToMapN() instead */
 static void
 QCBOREncode_AddMIMEDataToMapN(QCBOREncodeContext *pCtx,
                               int64_t             nLabel,
                               UsefulBufC          MIMEData);
 
+/* Use QCBOREncode_AddTDateString() instead */
 static void
-QCBOREncode_AddDateString(QCBOREncodeContext *pCtx,
-                          const char         *szDate);
+QCBOREncode_AddDateString(QCBOREncodeContext *pCtx, const char *szDate);
 
+/* Use QCBOREncode_AddTDateStringToMapSZ() instead */
 static void
 QCBOREncode_AddDateStringToMap(QCBOREncodeContext *pCtx,
                                const char         *szLabel,
                                const char         *szDate);
 
+/* Use QCBOREncode_AddTDateStringToMapN instead */
 static void
 QCBOREncode_AddDateStringToMapN(QCBOREncodeContext *pCtx,
                                 int64_t             nLabel,
                                 const char         *szDate);
 
+/* Use QCBOREncode_AddBoolToMapSZ() instead */
 static void
 QCBOREncode_AddBoolToMap(QCBOREncodeContext *pCtx, const char *szLabel, bool b);
 
+/* Use QCBOREncode_AddNULLToMapSZ() instead */
 static void
 QCBOREncode_AddNULLToMap(QCBOREncodeContext *pCtx, const char *szLabel);
 
+/* Use QCBOREncode_AddUndefToMapSZ() instead */
 static void
 QCBOREncode_AddUndefToMap(QCBOREncodeContext *pCtx, const char *szLabel);
 
+/* Use QCBOREncode_AddSimpleToMapSZ instead */
 static void
 QCBOREncode_AddSimpleToMap(QCBOREncodeContext *pCtx,
                            const char         *szLabel,
                            const uint8_t       uSimple);
 
+/* Use QCBOREncode_OpenArrayInMapSZ() instead */
 static void
 QCBOREncode_OpenArrayInMap(QCBOREncodeContext *pCtx, const char *szLabel);
 
+/* Use QCBOREncode_OpenMapInMapSZ() instead */
 static void
 QCBOREncode_OpenMapInMap(QCBOREncodeContext *pCtx, const char *szLabel);
 
+/* Use QCBOREncode_OpenArrayIndefiniteLengthInMapSZ() instead */
 static void
 QCBOREncode_OpenArrayIndefiniteLengthInMap(QCBOREncodeContext *pCtx,
                                            const char         *szLabel);
 
+/* Use QCBOREncode_OpenMapIndefiniteLengthInMapSZ() instead */
 static void
 QCBOREncode_OpenMapIndefiniteLengthInMap(QCBOREncodeContext *pCtx,
                                          const char         *szLabel);
 
+/* Use QCBOREncode_BstrWrapInMapSZ() instead */
 static void
 QCBOREncode_BstrWrapInMap(QCBOREncodeContext *pCtx, const char *szLabel);
 
+/* Use QCBOREncode_AddEncodedToMapSZ() instead */
 static void
 QCBOREncode_AddEncodedToMap(QCBOREncodeContext *pCtx, const char *szLabel, UsefulBufC Encoded);
 
diff --git a/inc/qcbor/qcbor_spiffy_decode.h b/inc/qcbor/qcbor_spiffy_decode.h
index fd2b0e5..e5ea0a9 100644
--- a/inc/qcbor/qcbor_spiffy_decode.h
+++ b/inc/qcbor/qcbor_spiffy_decode.h
@@ -1336,7 +1336,7 @@
  *
  * See @ref Tag-Usage for discussion on tag requirements.
  *
- * See also @ref CBOR_TAG_DATE_EPOCH, QCBOREncode_AddDateEpoch() and
+ * See also @ref CBOR_TAG_DATE_EPOCH, QCBOREncode_AddTDateEpoch() and
  * @ref QCBOR_TYPE_DATE_EPOCH.
 */
 void
@@ -1435,7 +1435,7 @@
  * QCBORDecode_GetDoubleConvertAll() which can convert big numbers.
  *
  * See also @ref CBOR_TAG_POS_BIGNUM, @ref CBOR_TAG_NEG_BIGNUM,
- * QCBOREncode_AddPositiveBignum(), QCBOREncode_AddNegativeBignum(),
+ * QCBOREncode_AddTPositiveBignum(), QCBOREncode_AddTNegativeBignum(),
  * @ref QCBOR_TYPE_POSBIGNUM and @ref QCBOR_TYPE_NEGBIGNUM.
  */
 // Improvement: Add function that converts integers and other to big nums
@@ -1502,7 +1502,7 @@
  * QCBORDecode_GetDoubleConvertAll() which can convert big numbers.
  *
  * See also @ref CBOR_TAG_DECIMAL_FRACTION,
- * QCBOREncode_AddDecimalFraction(), @ref QCBOR_TYPE_DECIMAL_FRACTION
+ * QCBOREncode_AddTDecimalFraction(), @ref QCBOR_TYPE_DECIMAL_FRACTION
  * and QCBORDecode_GetDecimalFractionBig().
  *
  * If QCBOR_DISABLE_TAGS is set, the only input this will decode is an
@@ -1555,7 +1555,7 @@
  * fractions.
  *
  * See also @ref CBOR_TAG_DECIMAL_FRACTION,
- * QCBOREncode_AddDecimalFraction(), @ref QCBOR_TYPE_DECIMAL_FRACTION
+ * QCBOREncode_AddTDecimalFraction(), @ref QCBOR_TYPE_DECIMAL_FRACTION
  * and QCBORDecode_GetDecimalFraction().
  */
 void
@@ -1609,7 +1609,7 @@
  * QCBORDecode_GetUInt64ConvertAll() and
  * QCBORDecode_GetDoubleConvertAll() which can convert big floats.
  *
- * See also @ref CBOR_TAG_BIGFLOAT, QCBOREncode_AddBigFloat(), @ref
+ * See also @ref CBOR_TAG_BIGFLOAT, QCBOREncode_AddTBigFloat(), @ref
  * QCBOR_TYPE_BIGFLOAT and QCBORDecode_GetBigFloatBig().
  */
 void
@@ -1652,7 +1652,7 @@
  * QCBORDecode_GetUInt64ConvertAll() and
  * QCBORDecode_GetDoubleConvertAll() which can convert big floats.
  *
- * See also @ref CBOR_TAG_BIGFLOAT, QCBOREncode_AddBigFloat(),
+ * See also @ref CBOR_TAG_BIGFLOAT, QCBOREncode_AddTBigFloat(),
  * @ref QCBOR_TYPE_BIGFLOAT and QCBORDecode_GetBigFloat().
  */
 void
@@ -1700,7 +1700,7 @@
  *
  * See @ref Tag-Usage for discussion on tag requirements.
  *
- * See also @ref CBOR_TAG_URI, QCBOREncode_AddURI() and
+ * See also @ref CBOR_TAG_URI, QCBOREncode_AddTURI() and
  *  @ref QCBOR_TYPE_URI.
  */
 static void
@@ -1775,7 +1775,7 @@
  *
  * Note that this does not actually remove the base64url encoding.
  *
- * See also @ref CBOR_TAG_B64URL, QCBOREncode_AddB64URLText() and
+ * See also @ref CBOR_TAG_B64URL, QCBOREncode_AddTB64URLText() and
  * @ref QCBOR_TYPE_BASE64URL.
  */
 static void
@@ -1810,7 +1810,7 @@
  *
  * See @ref Tag-Usage for discussion on tag requirements.
  *
- * See also @ref CBOR_TAG_REGEX, QCBOREncode_AddRegex() and
+ * See also @ref CBOR_TAG_REGEX, QCBOREncode_AddTRegex() and
  * @ref QCBOR_TYPE_REGEX.
  */
 static void
@@ -1898,7 +1898,7 @@
  *
  * See @ref Tag-Usage for discussion on tag requirements.
  *
- * See also @ref CBOR_TAG_BIN_UUID, QCBOREncode_AddBinaryUUID() and
+ * See also @ref CBOR_TAG_BIN_UUID, QCBOREncode_AddTBinaryUUID() and
  * @ref QCBOR_TYPE_UUID.
  */
 static void
diff --git a/src/qcbor_encode.c b/src/qcbor_encode.c
index 7657303..c30cbce 100644
--- a/src/qcbor_encode.c
+++ b/src/qcbor_encode.c
@@ -693,8 +693,8 @@
  * To output a mantissa that is between INT64_MAX and UINT64_MAX from 0,
  * it must be as a big number.
  *
- * Typically, QCBOREncode_AddDecimalFraction(), QCBOREncode_AddBigFloat(),
- * QCBOREncode_AddDecimalFractionBigNum() or QCBOREncode_AddBigFloatBigNum()
+ * Typically, QCBOREncode_AddTDecimalFraction(), QCBOREncode_AddTBigFloat(),
+ * QCBOREncode_AddTDecimalFractionBigNum() or QCBOREncode_AddTBigFloatBigNum()
  * is called instead of this.
  */
 void
@@ -718,9 +718,9 @@
    QCBOREncode_AddInt64(pMe, nExponent);
    if(!UsefulBuf_IsNULLC(BigNumMantissa)) {
       if(bBigNumIsNegative) {
-         QCBOREncode_AddNegativeBignum(pMe, BigNumMantissa);
+         QCBOREncode_AddTNegativeBignum(pMe, QCBOR_ENCODE_AS_TAG, BigNumMantissa);
       } else {
-         QCBOREncode_AddPositiveBignum(pMe, BigNumMantissa);
+         QCBOREncode_AddTPositiveBignum(pMe, QCBOR_ENCODE_AS_TAG, BigNumMantissa);
       }
    } else {
       QCBOREncode_AddInt64(pMe, nMantissa);
@@ -968,7 +968,7 @@
       return;
    }
    /* QCBOREncode_CancelBstrWrap() can't correctly undo
-    * QCBOREncode_BstrWrapInMap() or QCBOREncode_BstrWrapInMapN(). It
+    * QCBOREncode_BstrWrapInMapSZ() or QCBOREncode_BstrWrapInMapN(). It
     * can't undo the labels they add. It also doesn't catch the error
     * of using it this way.  QCBOREncode_CancelBstrWrap() is used
     * infrequently and the the result is incorrect CBOR, not a
diff --git a/test/qcbor_decode_tests.c b/test/qcbor_decode_tests.c
index 9f16668..e9745e3 100644
--- a/test/qcbor_decode_tests.c
+++ b/test/qcbor_decode_tests.c
@@ -6264,8 +6264,8 @@
    QCBOREncode_Init(&EC, UsefulBuf_FROM_BYTE_ARRAY(pBuf));
    QCBOREncode_OpenArray(&EC);
    QCBOREncode_AddDecimalFraction(&EC, 999, 1000); // 999 * (10 ^ 1000)
-   QCBOREncode_AddBigFloat(&EC, 100, INT32_MIN);
-   QCBOREncode_AddDecimalFractionBigNum(&EC, BN, false, INT32_MAX);
+   QCBOREncode_AddTBigFloat(&EC, QCBOR_ENCODE_AS_TAG, 100, INT32_MIN);
+   QCBOREncode_AddTDecimalFractionBigNum(&EC, QCBOR_ENCODE_AS_TAG, BN, false, INT32_MAX);
    QCBOREncode_CloseArray(&EC);
    QCBOREncode_Finish(&EC, &Encoded);
 
diff --git a/test/qcbor_encode_tests.c b/test/qcbor_encode_tests.c
index 3e8ec2f..14bcc63 100644
--- a/test/qcbor_encode_tests.c
+++ b/test/qcbor_encode_tests.c
@@ -681,7 +681,7 @@
    QCBOREncode_AddBool(pECtx, true);
    QCBOREncode_AddBool(pECtx, false);
    QCBOREncode_OpenMap(pECtx);
-   QCBOREncode_AddBoolToMap(pECtx, "George is the man", true);
+   QCBOREncode_AddBoolToMapSZ(pECtx, "George is the man", true);
    QCBOREncode_AddBoolToMapN(pECtx, 010101, true);
    QCBOREncode_CloseMap(pECtx);
 
@@ -929,7 +929,7 @@
 
    QCBOREncode_OpenMap(&ECtx);
 
-   QCBOREncode_AddUndefToMap(&ECtx, "UNDef");
+   QCBOREncode_AddUndefToMapSZ(&ECtx, "UNDef");
    QCBOREncode_CloseMap(&ECtx);
 
    QCBOREncode_CloseArray(&ECtx);
@@ -1191,32 +1191,32 @@
    QCBOREncode_OpenMap(&ECtx);
 
    // add array with 31 items
-   QCBOREncode_OpenArrayInMap(&ECtx, "arr");
+   QCBOREncode_OpenArrayInMapSZ(&ECtx, "arr");
    for (size_t ix = 0; ix < 31; ix++) {
       QCBOREncode_AddInt64(&ECtx, (int64_t)ix);
    }
    QCBOREncode_CloseArray(&ECtx);
 
    // add map with 31 items
-   QCBOREncode_OpenMapInMap(&ECtx, "map");
+   QCBOREncode_OpenMapInMapSZ(&ECtx, "map");
    for (int ix = 0; ix < 31; ix++) {
       // make sure we have unique keys in the map (a-z then follow by A-Z)
       int c = 'a';
       if (ix < 26) c = c + ix;
       else c = 'A' + (ix - 26);
       char buffer[2] = { (char)c, 0 };
-      QCBOREncode_AddInt64ToMap(&ECtx, buffer, ix);
+      QCBOREncode_AddInt64ToMapSZ(&ECtx, buffer, ix);
    }
    QCBOREncode_CloseMap(&ECtx);
 
    // add -31 and +31
-   QCBOREncode_AddInt64ToMap(&ECtx, "min31", -31);
-   QCBOREncode_AddInt64ToMap(&ECtx, "plus31", 31);
+   QCBOREncode_AddInt64ToMapSZ(&ECtx, "min31", -31);
+   QCBOREncode_AddInt64ToMapSZ(&ECtx, "plus31", 31);
 
    // add string with length 31
    const char *str = "testtesttesttesttesttestqcbor11";
    UsefulBufC str_b = { str, 31 };
-   QCBOREncode_AddTextToMap(&ECtx, "str", str_b);
+   QCBOREncode_AddTextToMapSZ(&ECtx, "str", str_b);
 
    QCBOREncode_CloseMap(&ECtx);
 
@@ -1295,9 +1295,10 @@
 
    QCBOREncode_OpenMap(&ECtx);
 
-   QCBOREncode_AddDateStringToMap(&ECtx,
-                                  "Sample Date from RFC 3339",
-                                  "1985-04-12T23:20:50.52Z");
+   QCBOREncode_AddTDateStringToMapSZ(&ECtx,
+                                     "Sample Date from RFC 3339",
+                                     QCBOR_ENCODE_AS_TAG,
+                                     "1985-04-12T23:20:50.52Z");
    QCBOREncode_AddDateEpochToMap(&ECtx, "SD", 999);
    QCBOREncode_AddTDaysStringToMapSZ(&ECtx,
                                      "Sample Date from RFC 8943",
@@ -1537,16 +1538,16 @@
    do {
       QCBOREncode_Init(&ECtx, (UsefulBuf){*pEncoded, *pEncodedLen});
       QCBOREncode_OpenMap(&ECtx);
-      QCBOREncode_AddInt64ToMap(&ECtx, "first integer", 42);
-      QCBOREncode_OpenArrayInMap(&ECtx, "an array of two strings");
+      QCBOREncode_AddInt64ToMapSZ(&ECtx, "first integer", 42);
+      QCBOREncode_OpenArrayInMapSZ(&ECtx, "an array of two strings");
       QCBOREncode_AddText(&ECtx, ((UsefulBufC) {"string1", 7}));
       QCBOREncode_AddText(&ECtx, ((UsefulBufC) {"string2", 7}));
       QCBOREncode_CloseArray(&ECtx);
-      QCBOREncode_OpenMapInMap(&ECtx, "map in a map");
+      QCBOREncode_OpenMapInMapSZ(&ECtx, "map in a map");
       QCBOREncode_AddBytesToMap(&ECtx,"bytes 1", ((UsefulBufC) { "xxxx", 4}));
-      QCBOREncode_AddBytesToMap(&ECtx, "bytes 2",((UsefulBufC) { "yyyy", 4}));
-      QCBOREncode_AddInt64ToMap(&ECtx, "another int", 98);
-      QCBOREncode_AddTextToMap(&ECtx, "text 2", ((UsefulBufC) {"lies, damn lies and statistics", 30}));
+      QCBOREncode_AddBytesToMapSZ(&ECtx, "bytes 2",((UsefulBufC) { "yyyy", 4}));
+      QCBOREncode_AddInt64ToMapSZ(&ECtx, "another int", 98);
+      QCBOREncode_AddTextToMapSZ(&ECtx, "text 2", ((UsefulBufC) {"lies, damn lies and statistics", 30}));
       QCBOREncode_CloseMap(&ECtx);
       QCBOREncode_CloseMap(&ECtx);
 
@@ -1683,10 +1684,10 @@
 
       // The result: 0 if scan happened and found nothing; 1 if it happened and
       // found something wrong; 2 if it didn't happen
-      QCBOREncode_AddSimpleToMap(&ECtx, "integrity", uRResult);
+      QCBOREncode_AddSimpleToMapSZ(&ECtx, "integrity", uRResult);
 
       // Add the diagnostic code
-      QCBOREncode_AddSZStringToMap(&ECtx, "type", szType);
+      QCBOREncode_AddSZStringToMapSZ(&ECtx, "type", szType);
 
       // Add a time stamp
       if(time) {
@@ -1694,24 +1695,24 @@
       }
 
       // Add the diagnostic code
-      QCBOREncode_AddSZStringToMap(&ECtx, "diag", szAlexString);
+      QCBOREncode_AddSZStringToMapSZ(&ECtx, "diag", szAlexString);
 
       // Open a subordinate map for telemtry data
-      QCBOREncode_OpenMapInMap(&ECtx, "telemetry");
+      QCBOREncode_OpenMapInMapSZ(&ECtx, "telemetry");
 
       { // Brace / indention just to show CBOR encoding nesting
 
          // Add a few fake integers and buffers for now.
-         QCBOREncode_AddInt64ToMap(&ECtx, "Shoe Size", 12);
+         QCBOREncode_AddInt64ToMapSZ(&ECtx, "Shoe Size", 12);
 
          // Add a few fake integers and buffers for now.
-         QCBOREncode_AddInt64ToMap(&ECtx, "IQ", 0xffffffff);
+         QCBOREncode_AddInt64ToMapSZ(&ECtx, "IQ", 0xffffffff);
 
          // Add a few fake integers and buffers for now.
          static const uint8_t pPV[] = {0x66, 0x67, 0x00, 0x56, 0xaa, 0xbb, 0x01, 0x01};
          const UsefulBufC WSPV = {pPV, sizeof(pPV)};
 
-         QCBOREncode_AddBytesToMap(&ECtx, "WhaleSharkPatternVector", WSPV);
+         QCBOREncode_AddBytesToMapSZ(&ECtx, "WhaleSharkPatternVector", WSPV);
       }
    }
 
@@ -2914,12 +2915,12 @@
    QCBOREncode_AddTDecimalFraction(&EC, QCBOR_ENCODE_AS_BORROWED, 4, -1); // 3 * (10 ^ -1)
    QCBOREncode_AddDecimalFractionBigNum(&EC, BigNum , false, -20);
    QCBOREncode_AddTDecimalFractionBigNum(&EC, QCBOR_ENCODE_AS_BORROWED, BigNum , false, 2);
-   QCBOREncode_AddDecimalFractionBigNum(&EC, BigNum, true, INT64_MAX);
+   QCBOREncode_AddTDecimalFractionBigNum(&EC, QCBOR_ENCODE_AS_TAG, BigNum, true, INT64_MAX);
    QCBOREncode_AddBigFloat(&EC, 100, 300);
    QCBOREncode_AddTBigFloat(&EC, QCBOR_ENCODE_AS_BORROWED, 200, 600);
    QCBOREncode_AddBigFloatBigNum(&EC, BigNum, false, -20);
    QCBOREncode_AddTBigFloatBigNum(&EC, QCBOR_ENCODE_AS_BORROWED, BigNum, false, 4);
-   QCBOREncode_AddBigFloatBigNum(&EC, BigNum, true, INT64_MIN);
+   QCBOREncode_AddTBigFloatBigNum(&EC, QCBOR_ENCODE_AS_TAG, BigNum, true, INT64_MIN);
    QCBOREncode_CloseArray(&EC);
 
    if(QCBOREncode_Finish(&EC, &EncodedExponentAndMantissa)) {
@@ -2952,17 +2953,19 @@
                                               false,
                                               INT32_MAX);
 
-   QCBOREncode_AddDecimalFractionBigNumToMapSZ(&EC,
-                                             "decimal fraction bignum negative",
-                                             BigNum,
-                                             true,
-                                             INT64_MAX);
+   QCBOREncode_AddTDecimalFractionBigNumToMapSZ(&EC,
+                                                "decimal fraction bignum negative",
+                                                QCBOR_ENCODE_AS_TAG,
+                                                BigNum,
+                                                true,
+                                                INT64_MAX);
 
-   QCBOREncode_AddDecimalFractionBigNumToMapN(&EC,
-                                              500,
-                                              BigNum,
-                                              true,
-                                              INT64_MAX);
+   QCBOREncode_AddTDecimalFractionBigNumToMapN(&EC,
+                                               500,
+                                               QCBOR_ENCODE_AS_TAG,
+                                               BigNum,
+                                               true,
+                                               INT64_MAX);
 
    QCBOREncode_AddBigFloatToMap(&EC, "big float", 100, 300);
 
@@ -2980,17 +2983,19 @@
                                        false,
                                        -20);
 
-   QCBOREncode_AddBigFloatBigNumToMap(&EC,
-                                      "big float bignum negative",
-                                      BigNum,
-                                      true,
-                                      INT64_MIN);
+   QCBOREncode_AddTBigFloatBigNumToMapSZ(&EC,
+                                         "big float bignum negative",
+                                         QCBOR_ENCODE_AS_TAG,
+                                         BigNum,
+                                         true,
+                                         INT64_MIN);
 
-   QCBOREncode_AddBigFloatBigNumToMapN(&EC,
-                                       800,
-                                       BigNum,
-                                       true,
-                                       INT64_MIN);
+   QCBOREncode_AddTBigFloatBigNumToMapN(&EC,
+                                        800,
+                                        QCBOR_ENCODE_AS_TAG,
+                                        BigNum,
+                                        true,
+                                        INT64_MIN);
 
    QCBOREncode_CloseMap(&EC);