diff --git a/icu4c/source/common/ucnv_io.c b/icu4c/source/common/ucnv_io.c
index 0d3e4c82e56..cf4c7f9ec8b 100644
--- a/icu4c/source/common/ucnv_io.c
+++ b/icu4c/source/common/ucnv_io.c
@@ -63,8 +63,8 @@
  * 3) This section contains a list of sorted unique aliases. This
  * list contains indexes into the string table for the alias name. The
  * index of this list is also used by other sections, like the 4th section.
- * The index for the 3rd and 4th section can be used to get the
- * alias <-> converter name mapping.
+ * The index for the 3rd and 4th section is used to get the
+ * alias -> converter name mapping. Section 3 and 4 form a two column table.
  *
  * 4) This section contains a list of mapped converter names. Consider this
  * as a table that maps the 3rd section to the 1st section. This list contains
@@ -148,40 +148,38 @@
  * Used by the UEnumeration API
  */
 typedef struct UAliasContext {
-    uint32_t standardNum;
-    uint32_t convNum;
+    uint32_t listOffset;
     uint32_t listIdx;
 } UAliasContext;
 
 static const char DATA_NAME[] = "cnvalias";
 static const char DATA_TYPE[] = "icu";
 
-static UDataMemory *aliasData=NULL;
+static UDataMemory *gAliasData=NULL;
 
-static const uint16_t *converterList = NULL;
-static const uint16_t *tagList = NULL;
-static const uint16_t *aliasList = NULL;
-static const uint16_t *untaggedConvArray = NULL;
-static const uint16_t *taggedAliasArray = NULL;
-static const uint16_t *taggedAliasLists = NULL;
-static const uint16_t *stringTable = NULL;
+static const uint16_t *gConverterList = NULL;
+static const uint16_t *gTagList = NULL;
+static const uint16_t *gAliasList = NULL;
+static const uint16_t *gUntaggedConvArray = NULL;
+static const uint16_t *gTaggedAliasArray = NULL;
+static const uint16_t *gTaggedAliasLists = NULL;
+static const uint16_t *gStringTable = NULL;
 
-static uint32_t converterListNum;
-static uint32_t tagListNum;
-static uint32_t aliasListNum;
-static uint32_t untaggedConvArraySize;
-static uint32_t taggedAliasArraySize;
-static uint32_t taggedAliasListsSize;
-static uint32_t stringTableSize;
+static uint32_t gConverterListSize;
+static uint32_t gTagListSize;
+static uint32_t gAliasListSize;
+static uint32_t gUntaggedConvArraySize;
+static uint32_t gTaggedAliasArraySize;
+static uint32_t gTaggedAliasListsSize;
+static uint32_t gStringTableSize;
 
-static const char **availableConverters = NULL;
-static uint16_t availableConverterCount = 0;
+static const char **gAvailableConverters = NULL;
+static uint16_t gAvailableConverterCount = 0;
 
-static char defaultConverterNameBuffer[UCNV_MAX_CONVERTER_NAME_LENGTH + 1]; /* +1 for NULL */
-static const char *defaultConverterName = NULL;
+static char gDefaultConverterNameBuffer[UCNV_MAX_CONVERTER_NAME_LENGTH + 1]; /* +1 for NULL */
+static const char *gDefaultConverterName = NULL;
 
-#define GET_STRING(idx) (const char *)(stringTable + (idx))
-#define NUM_RESERVED_TAGS 2
+#define GET_STRING(idx) (const char *)(gStringTable + (idx))
 
 static UBool U_CALLCONV
 isAcceptable(void *context,
@@ -205,7 +203,7 @@ haveAliasData(UErrorCode *pErrorCode) {
     }
 
     /* load converter alias data from file if necessary */
-    if(aliasData==NULL) {
+    if(gAliasData==NULL) {
         UDataMemory *data = NULL;
         const uint16_t *table = NULL;
         uint32_t tableStart;
@@ -227,43 +225,43 @@ haveAliasData(UErrorCode *pErrorCode) {
         }
 
         umtx_lock(NULL);
-        if(aliasData==NULL) {
-            aliasData = data;
+        if(gAliasData==NULL) {
+            gAliasData = data;
             data=NULL;
 
-            converterListNum        = ((const uint32_t *)(table))[1];
-            tagListNum              = ((const uint32_t *)(table))[2];
-            aliasListNum            = ((const uint32_t *)(table))[3];
-            untaggedConvArraySize   = ((const uint32_t *)(table))[4];
-            taggedAliasArraySize    = ((const uint32_t *)(table))[5];
-            taggedAliasListsSize    = ((const uint32_t *)(table))[6];
+            gConverterListSize      = ((const uint32_t *)(table))[1];
+            gTagListSize            = ((const uint32_t *)(table))[2];
+            gAliasListSize          = ((const uint32_t *)(table))[3];
+            gUntaggedConvArraySize  = ((const uint32_t *)(table))[4];
+            gTaggedAliasArraySize   = ((const uint32_t *)(table))[5];
+            gTaggedAliasListsSize   = ((const uint32_t *)(table))[6];
             reservedSize1           = ((const uint32_t *)(table))[7];   /* reserved */
-            stringTableSize         = ((const uint32_t *)(table))[8];
+            gStringTableSize        = ((const uint32_t *)(table))[8];
 
             currOffset = tableStart * (sizeof(uint32_t)/sizeof(uint16_t)) + (sizeof(uint32_t)/sizeof(uint16_t));
-            converterList = table + currOffset;
+            gConverterList = table + currOffset;
 
-            currOffset += converterListNum;
-            tagList = table + currOffset;
+            currOffset += gConverterListSize;
+            gTagList = table + currOffset;
 
-            currOffset += tagListNum;
-            aliasList = table + currOffset;
+            currOffset += gTagListSize;
+            gAliasList = table + currOffset;
 
-            currOffset += aliasListNum;
-            untaggedConvArray = table + currOffset;
+            currOffset += gAliasListSize;
+            gUntaggedConvArray = table + currOffset;
 
-            currOffset += untaggedConvArraySize;
-            taggedAliasArray = table + currOffset;
+            currOffset += gUntaggedConvArraySize;
+            gTaggedAliasArray = table + currOffset;
 
             /* aliasLists is a 1's based array, but it has a padding character */
-            currOffset += taggedAliasArraySize;
-            taggedAliasLists = table + currOffset;
+            currOffset += gTaggedAliasArraySize;
+            gTaggedAliasLists = table + currOffset;
 
-            currOffset += taggedAliasListsSize;
+            currOffset += gTaggedAliasListsSize;
             /* reserved */
 
             currOffset += reservedSize1;
-            stringTable = table + currOffset;
+            gStringTable = table + currOffset;
 
         }
         umtx_unlock(NULL);
@@ -277,7 +275,7 @@ haveAliasData(UErrorCode *pErrorCode) {
     return TRUE;
 }
 
-static UBool
+U_INLINE static UBool
 isAlias(const char *alias, UErrorCode *pErrorCode) {
     if(alias==NULL) {
         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
@@ -292,41 +290,41 @@ isAlias(const char *alias, UErrorCode *pErrorCode) {
 UBool 
 ucnv_io_cleanup()
 {
-    if (aliasData) {
-        udata_close(aliasData);
-        aliasData = NULL;
+    if (gAliasData) {
+        udata_close(gAliasData);
+        gAliasData = NULL;
     }
 
     ucnv_io_flushAvailableConverterCache();
 
-    converterListNum        = 0;
-    tagListNum              = 0;
-    aliasListNum            = 0;
-    untaggedConvArraySize   = 0;
-    taggedAliasArraySize    = 0;
-    taggedAliasListsSize    = 0;
-    stringTableSize         = 0;
+    gConverterListSize       = 0;
+    gTagListSize             = 0;
+    gAliasListSize           = 0;
+    gUntaggedConvArraySize   = 0;
+    gTaggedAliasArraySize    = 0;
+    gTaggedAliasListsSize    = 0;
+    gStringTableSize         = 0;
 
-    converterList = NULL;
-    tagList = NULL;
-    aliasList = NULL;
-    untaggedConvArray = NULL;
-    taggedAliasArray = NULL;
-    taggedAliasLists = NULL;
-    stringTable = NULL;
+    gConverterList = NULL;
+    gTagList = NULL;
+    gAliasList = NULL;
+    gUntaggedConvArray = NULL;
+    gTaggedAliasArray = NULL;
+    gTaggedAliasLists = NULL;
+    gStringTable = NULL;
 
-    defaultConverterName = NULL;
-    defaultConverterNameBuffer[0] = 0;
+    gDefaultConverterName = NULL;
+    gDefaultConverterNameBuffer[0] = 0;
 
     return TRUE;                   /* Everything was cleaned up */
 }
 
 
 static uint32_t getTagNumber(const char *tagname) {
-    if (tagList) {
+    if (gTagList) {
         uint32_t tagNum;
-        for (tagNum = 0; tagNum < tagListNum; tagNum++) {
-            if (!uprv_stricmp(GET_STRING(tagList[tagNum]), tagname)) {
+        for (tagNum = 0; tagNum < gTagListSize; tagNum++) {
+            if (!uprv_stricmp(GET_STRING(gTagList[tagNum]), tagname)) {
                 return tagNum;
             }
         }
@@ -384,7 +382,7 @@ ucnv_compareNames(const char *name1, const char *name2) {
 
 /*
  * search for an alias
- * return the converter number index for converterList
+ * return the converter number index for gConverterList
  */
 static uint32_t
 findConverter(const char *alias, UErrorCode *pErrorCode) {
@@ -393,13 +391,13 @@ findConverter(const char *alias, UErrorCode *pErrorCode) {
 
     /* do a binary search for the alias */
     start = 0;
-    limit = untaggedConvArraySize - 1;
+    limit = gUntaggedConvArraySize - 1;
     mid = limit;
 
     /* Once mid == 0 we've already checked the 0'th element and we can stop */
     while (start <= limit && mid != 0) {
         mid = (uint32_t)((start + limit + 1) / 2);    /* +1 is to round properly */
-        result = ucnv_compareNames(alias, GET_STRING(aliasList[mid]));
+        result = ucnv_compareNames(alias, GET_STRING(gAliasList[mid]));
 
         if (result < 0) {
             limit = mid-1;
@@ -407,25 +405,82 @@ findConverter(const char *alias, UErrorCode *pErrorCode) {
             start = mid+1;
         } else {
             /* Since the gencnval tool folds duplicates into one entry,
-             * this alias in aliasList is unique, but different standards
+             * this alias in gAliasList is unique, but different standards
              * may map an alias to different converters.
              */
-            if (untaggedConvArray[mid] & UCNV_AMBIGUOUS_ALIAS_MAP_BIT) {
+            if (gUntaggedConvArray[mid] & UCNV_AMBIGUOUS_ALIAS_MAP_BIT) {
                 *pErrorCode = U_AMBIGUOUS_ALIAS_WARNING;
             }
-            return untaggedConvArray[mid] & UCNV_CONVERTER_INDEX_MASK;
+            return gUntaggedConvArray[mid] & UCNV_CONVERTER_INDEX_MASK;
         }
     }
 
     return UINT32_MAX;
 }
 
+/*
+ * Search for an standard name of an alias (what is the default name
+ * that this standard uses?)
+ * return the listOffset for gTaggedAliasLists. If it's 0,
+ * the it couldn't be found, but the parameters are valid.
+ */
+static uint32_t
+findTaggedAliasListsOffset(const char *alias, const char *standard, UErrorCode *pErrorCode) {
+    uint32_t idx;
+    uint32_t listOffset;
+    uint32_t convNum;
+    UErrorCode myErr = U_ZERO_ERROR;
+    uint32_t tagNum = getTagNumber(standard);
+
+    /* Make a quick guess. Hopefully they used a TR22 canonical alias. */
+    convNum = findConverter(alias, &myErr);
+    if (myErr != U_ZERO_ERROR) {
+        *pErrorCode = myErr;
+    }
+
+    if (tagNum < (gTagListSize - UCNV_NUM_RESERVED_TAGS) && convNum < gConverterListSize) {
+        listOffset = gTaggedAliasArray[tagNum*gConverterListSize + convNum];
+        if (listOffset && gTaggedAliasLists[listOffset + 1]) {
+            return listOffset;
+        }
+        if (myErr == U_AMBIGUOUS_ALIAS_WARNING) {
+            /* Uh Oh! They used an ambiguous alias.
+               We have to search the whole swiss cheese starting
+               at the highest standard affinity.
+               This may take a while.
+            */
+            for (idx = 0; idx < gTaggedAliasArraySize; idx++) {
+                listOffset = gTaggedAliasArray[idx];
+                if (listOffset) {
+                    uint32_t currAlias;
+                    uint32_t listCount = gTaggedAliasLists[listOffset];
+                    /* +1 to skip listCount */
+                    const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
+                    for (currAlias = 0; currAlias < listCount; currAlias++) {
+                        if (currList[currAlias]
+                            && ucnv_compareNames(alias, GET_STRING(currList[currAlias]))==0)
+                        {
+                            return listOffset;
+                        }
+                    }
+                }
+            }
+            /* The standard doesn't know about the alias */
+        }
+        /* else no default name */
+        return 0;
+    }
+    /* else converter or tag not found */
+
+    return UINT32_MAX;
+}
+
 U_CFUNC const char *
 ucnv_io_getConverterName(const char *alias, UErrorCode *pErrorCode) {
     if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
         uint32_t convNum = findConverter(alias, pErrorCode);
-        if (convNum < converterListNum) {
-            return GET_STRING(converterList[convNum]);
+        if (convNum < gConverterListSize) {
+            return GET_STRING(gConverterList[convNum]);
         }
         /* else converter not found */
     }
@@ -436,10 +491,10 @@ static int32_t U_CALLCONV
 ucnv_io_countStandardAliases(UEnumeration *enumerator, UErrorCode *pErrorCode) {
     int32_t value = 0;
     UAliasContext *myContext = (UAliasContext *)(enumerator->context);
-    uint32_t listOffset = taggedAliasArray[myContext->standardNum*converterListNum + myContext->convNum];
+    uint32_t listOffset = myContext->listOffset;
 
     if (listOffset) {
-        value = taggedAliasLists[listOffset];
+        value = gTaggedAliasLists[listOffset];
     }
     return value;
 }
@@ -450,11 +505,11 @@ ucnv_io_nextStandardAliases(UEnumeration *enumerator,
                             UErrorCode *pErrorCode)
 {
     UAliasContext *myContext = (UAliasContext *)(enumerator->context);
-    uint32_t listOffset = taggedAliasArray[myContext->standardNum*converterListNum + myContext->convNum];
+    uint32_t listOffset = myContext->listOffset;
 
     if (listOffset) {
-        uint32_t listCount = taggedAliasLists[listOffset];
-        const uint16_t *currList = taggedAliasLists + listOffset + 1;
+        uint32_t listCount = gTaggedAliasLists[listOffset];
+        const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
 
         if (myContext->listIdx < listCount) {
             const char *myStr = GET_STRING(currList[myContext->listIdx++]);
@@ -498,9 +553,9 @@ ucnv_openStandardNames(const char *convName,
 {
     UEnumeration *myEnum = NULL;
     if (haveAliasData(pErrorCode) && isAlias(convName, pErrorCode)) {
-        uint32_t convNum = findConverter(convName, pErrorCode);
-        uint32_t tagNum = getTagNumber(standard);
-        if (tagNum < (tagListNum - NUM_RESERVED_TAGS) && convNum < converterListNum) {
+        uint32_t listOffset = findTaggedAliasListsOffset(convName, standard, pErrorCode);
+
+        if (listOffset < gTaggedAliasListsSize) {
             UAliasContext *myContext;
 
             myEnum = uprv_malloc(sizeof(UEnumeration));
@@ -516,8 +571,7 @@ ucnv_openStandardNames(const char *convName,
                 return NULL;
             }
             myEnum->context = myContext;
-            myContext->standardNum = tagNum;
-            myContext->convNum = convNum;
+            myContext->listOffset = listOffset;
             myContext->listIdx = 0;
         }
         /* else converter or tag not found */
@@ -529,12 +583,12 @@ U_CFUNC uint16_t
 ucnv_io_countAliases(const char *alias, UErrorCode *pErrorCode) {
     if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
         uint32_t convNum = findConverter(alias, pErrorCode);
-        if (convNum < converterListNum) {
+        if (convNum < gConverterListSize) {
             /* tagListNum - 1 is the ALL tag */
-            int32_t listOffset = taggedAliasArray[(tagListNum - 1)*converterListNum + convNum];
+            int32_t listOffset = gTaggedAliasArray[(gTagListSize - 1)*gConverterListSize + convNum];
 
             if (listOffset) {
-                return taggedAliasLists[listOffset];
+                return gTaggedAliasLists[listOffset];
             }
             /* else this shouldn't happen. internal program error */
         }
@@ -548,14 +602,14 @@ ucnv_io_getAliases(const char *alias, uint16_t start, const char **aliases, UErr
     if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
         uint32_t currAlias;
         uint32_t convNum = findConverter(alias, pErrorCode);
-        if (convNum < converterListNum) {
+        if (convNum < gConverterListSize) {
             /* tagListNum - 1 is the ALL tag */
-            int32_t listOffset = taggedAliasArray[(tagListNum - 1)*converterListNum + convNum];
+            int32_t listOffset = gTaggedAliasArray[(gTagListSize - 1)*gConverterListSize + convNum];
 
             if (listOffset) {
-                uint32_t listCount = taggedAliasLists[listOffset];
+                uint32_t listCount = gTaggedAliasLists[listOffset];
                 /* +1 to skip listCount */
-                const uint16_t *currList = taggedAliasLists + listOffset + 1;
+                const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
 
                 for (currAlias = start; currAlias < listCount; currAlias++) {
                     aliases[currAlias] = GET_STRING(currList[currAlias]);
@@ -572,14 +626,14 @@ U_CFUNC const char *
 ucnv_io_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode) {
     if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
         uint32_t convNum = findConverter(alias, pErrorCode);
-        if (convNum < converterListNum) {
+        if (convNum < gConverterListSize) {
             /* tagListNum - 1 is the ALL tag */
-            int32_t listOffset = taggedAliasArray[(tagListNum - 1)*converterListNum + convNum];
+            int32_t listOffset = gTaggedAliasArray[(gTagListSize - 1)*gConverterListSize + convNum];
 
             if (listOffset) {
-                uint32_t listCount = taggedAliasLists[listOffset];
+                uint32_t listCount = gTaggedAliasLists[listOffset];
                 /* +1 to skip listCount */
-                const uint16_t *currList = taggedAliasLists + listOffset + 1;
+                const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
 
                 if (n < listCount)  {
                     return GET_STRING(currList[n]);
@@ -597,7 +651,7 @@ U_CFUNC uint16_t
 ucnv_io_countStandards(UErrorCode *pErrorCode) {
     if (haveAliasData(pErrorCode)) {
         /* Don't include the empty list */
-        return (uint16_t)(tagListNum - NUM_RESERVED_TAGS);
+        return (uint16_t)(gTagListSize - UCNV_NUM_RESERVED_TAGS);
     }
 
     return 0;
@@ -606,8 +660,8 @@ ucnv_io_countStandards(UErrorCode *pErrorCode) {
 U_CAPI const char * U_EXPORT2
 ucnv_getStandard(uint16_t n, UErrorCode *pErrorCode) {
     if (haveAliasData(pErrorCode)) {
-        if (n < tagListNum - NUM_RESERVED_TAGS) {
-            return GET_STRING(tagList[n]);
+        if (n < gTagListSize - UCNV_NUM_RESERVED_TAGS) {
+            return GET_STRING(gTagList[n]);
         }
         *pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
     }
@@ -618,54 +672,18 @@ ucnv_getStandard(uint16_t n, UErrorCode *pErrorCode) {
 U_CAPI const char * U_EXPORT2
 ucnv_getStandardName(const char *alias, const char *standard, UErrorCode *pErrorCode) {
     if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
-        uint32_t idx;
-        uint32_t listOffset;
-        uint32_t convNum;
-        uint32_t tagNum = getTagNumber(standard);
-        UErrorCode myErr = U_ZERO_ERROR;
+        uint32_t listOffset = findTaggedAliasListsOffset(alias, standard, pErrorCode);
 
-        /* Make a quick guess. Hopefully they used a TR22 canonical alias. */
-        convNum = findConverter(alias, &myErr);
+        if (listOffset < gTaggedAliasListsSize) {
+            const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
 
-        if (tagNum < (tagListNum - NUM_RESERVED_TAGS) && convNum < converterListNum) {
-            if (myErr == U_AMBIGUOUS_ALIAS_WARNING) {
-                /* Uh Oh! They used an ambiguous alias.
-                   Hopefully the standard knows the alias.
-                   This may take a while.
-                */
-                for (idx = 0; idx < converterListNum; idx++) {
-                    listOffset = taggedAliasArray[tagNum*converterListNum + idx];
-                    if (listOffset) {
-                        uint32_t currAlias;
-                        uint32_t listCount = taggedAliasLists[listOffset];
-                        /* +1 to skip listCount */
-                        const uint16_t *currList = taggedAliasLists + listOffset + 1;
-                        for (currAlias = 0; currAlias < listCount; currAlias++) {
-                            if (currList[currAlias]
-                                && ucnv_compareNames(alias, GET_STRING(currList[currAlias]))==0)
-                            {
-                                /* Get the preferred name from this list */
-                                if (currList[0]) {
-                                    return GET_STRING(currList[0]);
-                                }
-                                else {
-                                    /* Someone screwed up the alias table. */
-                                    return NULL;
-                                }
-                            }
-                        }
-                    }
-                }
-                /* The standard doesn't know about the alias */
-                *pErrorCode = U_AMBIGUOUS_ALIAS_WARNING;
+            /* Get the preferred name from this list */
+            if (currList[0]) {
+                return GET_STRING(currList[0]);
             }
-            listOffset = taggedAliasArray[tagNum*converterListNum + convNum];
-            if (listOffset && taggedAliasLists[listOffset + 1]) {
-                return GET_STRING(taggedAliasLists[listOffset + 1]);
-            }
-            /* else no default name */
+            /* else someone screwed up the alias table. */
+            /* *pErrorCode = U_INVALID_FORMAT_ERROR */
         }
-        /* else converter or tag not found */
     }
 
     return NULL;
@@ -673,17 +691,17 @@ ucnv_getStandardName(const char *alias, const char *standard, UErrorCode *pError
 
 void
 ucnv_io_flushAvailableConverterCache() {
-    if (availableConverters) {
+    if (gAvailableConverters) {
         umtx_lock(NULL);
-        availableConverterCount = 0;
-        uprv_free((char **)availableConverters);
-        availableConverters = NULL;
+        gAvailableConverterCount = 0;
+        uprv_free((char **)gAvailableConverters);
+        gAvailableConverters = NULL;
         umtx_unlock(NULL);
     }
 }
 
 static UBool haveAvailableConverterList(UErrorCode *pErrorCode) {
-    if (availableConverters == NULL) {
+    if (gAvailableConverters == NULL) {
         uint16_t idx;
         uint16_t localConverterCount;
         UErrorCode status;
@@ -695,7 +713,7 @@ static UBool haveAvailableConverterList(UErrorCode *pErrorCode) {
         }
 
         /* We can't have more than "*converterTable" converters to open */
-        localConverterList = (const char **) uprv_malloc(converterListNum * sizeof(char*));
+        localConverterList = (const char **) uprv_malloc(gConverterListSize * sizeof(char*));
         if (!localConverterList) {
             *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
             return FALSE;
@@ -703,9 +721,9 @@ static UBool haveAvailableConverterList(UErrorCode *pErrorCode) {
 
         localConverterCount = 0;
 
-        for (idx = 0; idx < converterListNum; idx++) {
+        for (idx = 0; idx < gConverterListSize; idx++) {
             status = U_ZERO_ERROR;
-            converterName = GET_STRING(converterList[idx]);
+            converterName = GET_STRING(gConverterList[idx]);
             ucnv_close(ucnv_open(converterName, &status));
             if (U_SUCCESS(status)) {
                 localConverterList[localConverterCount++] = converterName;
@@ -713,9 +731,9 @@ static UBool haveAvailableConverterList(UErrorCode *pErrorCode) {
         }
 
         umtx_lock(NULL);
-        if (availableConverters == NULL) {
-            availableConverters = localConverterList;
-            availableConverterCount = localConverterCount;
+        if (gAvailableConverters == NULL) {
+            gAvailableConverters = localConverterList;
+            gAvailableConverterCount = localConverterCount;
         }
         else {
             uprv_free((char **)localConverterList);
@@ -728,7 +746,7 @@ static UBool haveAvailableConverterList(UErrorCode *pErrorCode) {
 U_CFUNC uint16_t
 ucnv_io_countAvailableConverters(UErrorCode *pErrorCode) {
     if (haveAvailableConverterList(pErrorCode)) {
-        return availableConverterCount;
+        return gAvailableConverterCount;
     }
     return 0;
 }
@@ -736,8 +754,8 @@ ucnv_io_countAvailableConverters(UErrorCode *pErrorCode) {
 U_CFUNC const char *
 ucnv_io_getAvailableConverter(uint16_t n, UErrorCode *pErrorCode) {
     if (haveAvailableConverterList(pErrorCode)) {
-        if (n < availableConverterCount) {
-            return availableConverters[n];
+        if (n < gAvailableConverterCount) {
+            return gAvailableConverters[n];
         }
         *pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
     }
@@ -748,8 +766,8 @@ U_CFUNC void
 ucnv_io_fillAvailableConverters(const char **aliases, UErrorCode *pErrorCode) {
     if (haveAvailableConverterList(pErrorCode)) {
         uint16_t count = 0;
-        while (count < availableConverterCount) {
-            *aliases++=availableConverters[count++];
+        while (count < gAvailableConverterCount) {
+            *aliases++=gAvailableConverters[count++];
         }
     }
 }
@@ -757,7 +775,7 @@ ucnv_io_fillAvailableConverters(const char **aliases, UErrorCode *pErrorCode) {
 U_CFUNC uint16_t
 ucnv_io_countAvailableAliases(UErrorCode *pErrorCode) {
     if (haveAliasData(pErrorCode)) {
-        return (uint16_t)aliasListNum;
+        return (uint16_t)gAliasListSize;
     }
     return 0;
 }
@@ -775,7 +793,7 @@ ucnv_io_countAvailableAliases(UErrorCode *pErrorCode) {
 U_CFUNC const char *
 ucnv_io_getDefaultConverterName() {
     /* local variable to be thread-safe */
-    const char *name=defaultConverterName;
+    const char *name=gDefaultConverterName;
     if(name==NULL) {
         const char *codepage = uprv_getDefaultCodepage();
         if(codepage!=NULL) {
@@ -807,7 +825,7 @@ ucnv_io_getDefaultConverterName() {
         if(name != NULL) {
             umtx_lock(NULL);
             /* Did find a name. And it works.*/
-            defaultConverterName=name;
+            gDefaultConverterName=name;
             umtx_unlock(NULL);
         }
     }
@@ -819,27 +837,27 @@ U_CFUNC void
 ucnv_io_setDefaultConverterName(const char *converterName) {
     if(converterName==NULL) {
         /* reset to the default codepage */
-        defaultConverterName=NULL;
+        gDefaultConverterName=NULL;
     } else {
         UErrorCode errorCode=U_ZERO_ERROR;
         const char *name=ucnv_io_getConverterName(converterName, &errorCode);
         if(U_SUCCESS(errorCode) && name!=NULL) {
-            defaultConverterName=name;
+            gDefaultConverterName=name;
         } else {
             /* do not set the name if the alias lookup failed and it is too long */
             int32_t length=(int32_t)(uprv_strlen(converterName));
-            if(length<sizeof(defaultConverterNameBuffer)) {
+            if(length<sizeof(gDefaultConverterNameBuffer)) {
                 /* it was not found as an alias, so copy it - accept an empty name */
                 UBool didLock;
-                if(defaultConverterName==defaultConverterNameBuffer) {
+                if(gDefaultConverterName==gDefaultConverterNameBuffer) {
                     umtx_lock(NULL);
                     didLock=TRUE;
                 } else {
                     didLock=FALSE;
                 }
-                uprv_memcpy(defaultConverterNameBuffer, converterName, length);
-                defaultConverterNameBuffer[length]=0;
-                defaultConverterName=defaultConverterNameBuffer;
+                uprv_memcpy(gDefaultConverterNameBuffer, converterName, length);
+                gDefaultConverterNameBuffer[length]=0;
+                gDefaultConverterName=gDefaultConverterNameBuffer;
                 if(didLock) {
                     umtx_unlock(NULL);
                 }
diff --git a/icu4c/source/common/ucnv_io.h b/icu4c/source/common/ucnv_io.h
index b950431d50c..7b37970a426 100644
--- a/icu4c/source/common/ucnv_io.h
+++ b/icu4c/source/common/ucnv_io.h
@@ -17,6 +17,7 @@
 
 #define UCNV_AMBIGUOUS_ALIAS_MAP_BIT 0x8000
 #define UCNV_CONVERTER_INDEX_MASK 0xFFF
+#define UCNV_NUM_RESERVED_TAGS 2
 
 /**
  * Map a converter alias name to a canonical converter name.
diff --git a/icu4c/source/common/unicode/ucnv.h b/icu4c/source/common/unicode/ucnv.h
index 8ab509eadba..63133f42094 100644
--- a/icu4c/source/common/unicode/ucnv.h
+++ b/icu4c/source/common/unicode/ucnv.h
@@ -224,6 +224,8 @@ ucnv_compareNames(const char *name1, const char *name2);
  * <code>UCNV_OPTION_SEP_CHAR</code> between the name and the first option and
  * also between adjacent options.</p>
  *
+ * If the alias is ambiguous, then the preferred converter is used
+ * and the status is set to U_AMBIGUOUS_ALIAS_WARNING.
  * @param converterName : name of the uconv table, may have options appended
  * @param err outgoing error status <TT>U_MEMORY_ALLOCATION_ERROR, U_FILE_ACCESS_ERROR</TT>
  * @return the created Unicode converter object, or <TT>NULL</TT> if an error occured
@@ -245,6 +247,8 @@ ucnv_open   (const char *converterName, UErrorCode * err);
  * E.g., the names "UTF8", "utf-8", and "Utf 8" are all equivalent.
  * If <TT>NULL</TT> is passed for the converter name, it will create 
  * one with the ucnv_getDefaultName() return value.
+ * If the alias is ambiguous, then the preferred converter is used
+ * and the status is set to U_AMBIGUOUS_ALIAS_WARNING.
  * @param name : name of the uconv table in a zero terminated 
  *        Unicode string
  * @param err outgoing error status <TT>U_MEMORY_ALLOCATION_ERROR, 
@@ -308,6 +312,9 @@ ucnv_openU (const UChar * name,
  *     cnv=ucnv_open(name, &errorCode);
  * \endcode
  *
+ * If the alias is ambiguous, then the preferred converter is used
+ * and the status is set to U_AMBIGUOUS_ALIAS_WARNING.
+ *
  * @param codepage codepage number to create
  * @param platform the platform in which the codepage number exists
  * @param err error status <TT>U_MEMORY_ALLOCATION_ERROR, U_FILE_ACCESS_ERROR</TT>
@@ -1014,6 +1021,8 @@ ucnv_getAvailableName (int32_t n);
 
 /**
  * Gives the number of aliases for a given converter or alias name.
+ * If the alias is ambiguous, then the preferred converter is used
+ * and the status is set to U_AMBIGUOUS_ALIAS_WARNING.
  * This method only enumerates the listed entries in the alias file.
  * @param alias alias name
  * @param pErrorCode error status
@@ -1026,6 +1035,8 @@ ucnv_countAliases(const char *alias, UErrorCode *pErrorCode);
 /**
  * Gives the name of the alias at given index of alias list.
  * This method only enumerates the listed entries in the alias file.
+ * If the alias is ambiguous, then the preferred converter is used
+ * and the status is set to U_AMBIGUOUS_ALIAS_WARNING.
  * @param alias alias name
  * @param n index in alias list
  * @param pErrorCode result of operation
@@ -1039,6 +1050,8 @@ ucnv_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode);
 /**
  * Fill-up the list of alias names for the given alias.
  * This method only enumerates the listed entries in the alias file.
+ * If the alias is ambiguous, then the preferred converter is used
+ * and the status is set to U_AMBIGUOUS_ALIAS_WARNING.
  * @param alias alias name
  * @param aliases fill-in list, aliases is a pointer to an array of
  *        <code>ucnv_countAliases()</code> string-pointers
diff --git a/icu4c/source/data/mappings/convrtrs.txt b/icu4c/source/data/mappings/convrtrs.txt
index 289d4fb6568..f40a9360ab5 100644
--- a/icu4c/source/data/mappings/convrtrs.txt
+++ b/icu4c/source/data/mappings/convrtrs.txt
@@ -78,20 +78,21 @@
 # be the first converter that will be opened.
 #
 # The general ordering is from specific and frequently used to more general
-# and rarely used.
+# or rarely used.
 {   UTR22           # Name format specified by http://www.unicode.org/unicode/reports/tr22/
     # ICU             # Can also use ICU_FEATURE
     IBM             # The IBM CCSID number is specified by ibm-*
-    WINDOWS         # The Microsoft code page identifier number is specified by cp*
+    # WINDOWS         # The Microsoft code page identifier number is specified by cp*
     JAVA            # Source: Sun JDK. Preferred name must be an exact match. Alias name case is ignored, but dashes are not ignored.
     # GLIBC
-    # AIX DB2
+    # AIX
+	# DB2
     # SOLARIS
     # APPLE
     # HPUX
     IANA            # Source: http://www.iana.org/assignments/character-sets
     MIME            # Source: http://www.iana.org/assignments/character-sets
-    # MSIE            # MSIE is Internet Explorer, which can be different from Windows
+    # MSIE            # MSIE is Internet Explorer, which can be different from Windows (From the IMultiLanguage COM interface)
     ZOS_USS         # z/OS (os/390) Unix System Services (USS), which has NL<->LF swapping. They have the same format as the IBM tag.
     }
 
@@ -99,22 +100,38 @@
 
 # Fully algorithmic converters
 
-UTF-8 { IANA* MIME* }           ibm-1208 ibm-1209 ibm-5304 ibm-5305 cp1208 cp65001
+UTF-8 { IANA* MIME* }           ibm-1208 { IBM* }
+                                ibm-1209 { IBM }
+                                ibm-5304 { IBM }
+                                ibm-5305 { IBM }
+                                cp1208
+                                cp65001
 
 # The ICU 2.2 UTF-16/32 converters detect and write a BOM.
 UTF-16 { IANA* MIME* }          ISO-10646-UCS-2 { IANA } csUnicode ucs-2
-UTF-16BE { IANA* MIME* }        UTF16_BigEndian x-utf-16be ibm-1200 ibm-1201 ibm-5297 ibm-13488 ibm-17584 cp1201
-UTF-16LE { IANA* MIME* }        UTF16_LittleEndian x-utf-16le ibm-1202 ibm-13490 ibm-17586 cp1200
+UTF-16BE { IANA* MIME* }        UTF16_BigEndian
+                                x-utf-16be
+                                ibm-1200 { IBM* }
+                                ibm-1201 { IBM }
+                                ibm-5297 { IBM }
+                                ibm-13488 { IBM }
+                                ibm-17584 { IBM }
+                                cp1201
+UTF-16LE { IANA* MIME* }        UTF16_LittleEndian
+                                x-utf-16le
+                                ibm-1202 { IBM* }
+                                ibm-13490 { IBM }
+                                ibm-17586 { IBM }
+                                cp1200
+
+UTF-32 { IANA* MIME* }          ISO-10646-UCS-4 { IANA } csUCS4 ucs-4
+UTF-32BE { IANA* }              UTF32_BigEndian ibm-1232 { IBM* } ibm-1233 { IBM }
+UTF-32LE { IANA* }              UTF32_LittleEndian ibm-1234 { IBM* }
 
 # ICU-specific names for special uses
 UTF16_PlatformEndian
 UTF16_OppositeEndian
 
-UTF-32 { IANA* MIME* }          ISO-10646-UCS-4 { IANA } csUCS4 ucs-4
-UTF-32BE { IANA* }              UTF32_BigEndian ibm-1232 ibm-1233
-UTF-32LE { IANA* }              UTF32_LittleEndian ibm-1234
-
-# ICU-specific names for special uses
 UTF32_PlatformEndian
 UTF32_OppositeEndian
 
@@ -138,7 +155,7 @@ CESU-8 { IANA* }
 
 ISO-8859-1 { MIME* IANA }
     LATIN_1     # Old ICU name
-    ibm-819
+    ibm-819 { IBM* }
     IBM819 { IANA }
     cp819 { IANA }
     latin1 { IANA }
@@ -163,6 +180,7 @@ US-ASCII { MIME* IANA }
     646 { JAVA }
     iso-ir-6 { IANA }
     cp367 { IANA }
+    # IBM367 { IANA } # Leave this on ibm-367 so it can have an IANA name
     # Java says "default" too, but that makes no sense.
 
 # Partially algorithmic converters
@@ -208,12 +226,12 @@ LMBCS-19
 
 # Table-based interchange codepages
 
-ibm-367                 IBM367 { IANA* }    # This is ASCII, but it has fallbacks
+ibm-367 { IBM* }        IBM367 { IANA* }    # This is ASCII, but it has fallbacks
 
 # Central Europe
 # Standard iso-8859-1, which does not have the Euro update.
 # See iso-8859-15 (latin9) for the Euro update
-ibm-912                 iso-8859-2 { MIME* IANA }
+ibm-912 { IBM* }        iso-8859-2 { MIME* IANA }
                         latin2 { IANA }
                         # ISO8859_2 { JAVA* } # This is really the default for Java and many others.
                         8859-2
@@ -225,7 +243,7 @@ ibm-912                 iso-8859-2 { MIME* IANA }
                         912
 
 # Maltese Esperanto
-ibm-913                 iso-8859-3 { MIME* IANA }
+ibm-913 { IBM* }        iso-8859-3 { MIME* IANA }
                         latin3 { IANA }
                         8859-3
                         csISOLatin3 { IANA }
@@ -236,7 +254,7 @@ ibm-913                 iso-8859-3 { MIME* IANA }
                         913
 
 # Baltic
-ibm-914                 iso-8859-4 { MIME* IANA }
+ibm-914 { IBM* }        iso-8859-4 { MIME* IANA }
                         latin4 { IANA }
                         8859-4
                         csISOLatin4 { IANA }
@@ -247,7 +265,7 @@ ibm-914                 iso-8859-4 { MIME* IANA }
                         914
 
 # Cyrillic
-ibm-915                 iso-8859-5 { MIME* IANA }
+ibm-915 { IBM* }        iso-8859-5 { MIME* IANA }
                         cyrillic { IANA }
                         8859-5
                         csISOLatinCyrillic { IANA }
@@ -259,7 +277,7 @@ ibm-915                 iso-8859-5 { MIME* IANA }
 # Arabic
 # ISO_8859-6-E and ISO_8859-6-I are similar to this charset, but they are not the same
 # -E means explicit. -I means implicit.  However those aliases are rarely used.
-ibm-1089                iso-8859-6 { MIME* IANA }
+ibm-1089 { IBM* }       iso-8859-6 { MIME* IANA }
                         arabic { IANA }
                         8859-6
                         csISOLatinArabic { IANA }
@@ -271,7 +289,7 @@ ibm-1089                iso-8859-6 { MIME* IANA }
                         1089
 
 # ISO Greek (w/ euro update)
-ibm-4909                iso-8859-7 { MIME* IANA }
+ibm-4909 { IBM* }       iso-8859-7 { MIME* IANA }
                         greek { IANA }
                         greek8 { IANA }
                         elot_928 { IANA }
@@ -287,7 +305,7 @@ ibm-813                 # Same as 4909 above but without the euro update
 # hebrew
 # ISO_8859-8-E and ISO_8859-8-I are similar to this charset, but they are not the same
 # -E means explicit. -I means implicit.
-ibm-916                 iso-8859-8 { MIME* IANA }
+ibm-916 { IBM* }        iso-8859-8 { MIME* IANA }
                         hebrew { IANA }
                         8859-8
                         csISOLatinHebrew { IANA }
@@ -297,7 +315,7 @@ ibm-916                 iso-8859-8 { MIME* IANA }
                         916
 
 # Turkish
-ibm-920                 iso-8859-9 { MIME* IANA }
+ibm-920 { IBM* }        iso-8859-9 { MIME* IANA }
                         ECMA-128    # IANA doesn't have this alias 6/24/2002
                         latin5 { IANA }
                         8859-9
@@ -309,7 +327,7 @@ ibm-920                 iso-8859-9 { MIME* IANA }
                         920
 
 # Latin 9
-ibm-923                 iso-8859-15 { IANA* MIME* } # IANA only has iso-8859-15 (6/24/2002)
+ibm-923 { IBM* }        iso-8859-15 { IANA* MIME* } # IANA only has iso-8859-15 (6/24/2002)
                         # ISO8859_15 { JAVA* } # This is really the default for Java and many others.
                         8859-15
                         latin9
@@ -320,14 +338,50 @@ ibm-923                 iso-8859-15 { IANA* MIME* } # IANA only has iso-8859-15
                         cp923
                         923
 
-ibm-1252                ibm-1004 cp1004      # Windows Latin 1 without Euro
-ibm-942_P120-2000       ibm-942_VASCII_VSUB_VPUA ibm-942 ibm-932 ibm-932_VASCII_VSUB_VPUA   # Old s_jis ibm-932 added!   
-ibm-942_P12A-2000       ibm-942_VSUB_VPUA shift_jis78 sjis78 ibm-932_VSUB_VPUA
-ibm-943_P130-2000       ibm-943_VASCII_VSUB_VPUA ibm-943 # japanese. Unicode name is \u30b7\u30d5\u30c8\u7b26\u53f7\u5316\u8868\u73fe Iana says that Windows-31J is an extension to csshiftjis ibm-932 removed
-ibm-943_P14A-2000       ibm-943_VSUB_VPUA Shift_JIS { MIME* } csWindows31J sjis cp943 cp932 pck ms_kanji csshiftjis windows-31j  x-sjis 943
-ibm-949_P110-2000       ibm-949_VASCII_VSUB_VPUA ibm-949
+# Windows Latin 1 without Euro
+ibm-1252 { IBM* }       # ibm-1004 and cp1004 are different from this mapping table
 
-ibm-949_P11A-2000
+
+# CJK encodings
+
+ibm-942_P120-2000 { UTR22* }
+                        ibm-942 { IBM* }
+                        ibm-942_VASCII_VSUB_VPUA
+                        ibm-932 { IBM }
+                        ibm-932_VASCII_VSUB_VPUA   # Old s_jis
+ibm-942_P12A-2000 { UTR22* }    # The normal mapping
+                        ibm-942 # Leave untagged because this isn't the default
+                        ibm-942_VSUB_VPUA
+                        shift_jis78
+                        sjis78
+                        ibm-932_VSUB_VPUA
+
+ibm-943_P130-2000 { UTR22* }
+                        ibm-943 { IBM* }
+                        ibm-943_VASCII_VSUB_VPUA
+                        Shift_JIS # Leave untagged because this isn't the default
+                        # japanese. Unicode name is \u30b7\u30d5\u30c8\u7b26\u53f7\u5316\u8868\u73fe
+ibm-943_P14A-2000 { UTR22* }
+                        ibm-943 # Leave untagged because this isn't the default
+                        ibm-943_VSUB_VPUA
+                        Shift_JIS { IANA* MIME* }
+                        sjis
+                        cp943
+                        cp932
+                        pck     # Probably SOLARIS
+                        MS_Kanji { IANA }
+                        csShiftJIS { IANA }
+                        windows-31j { IANA } # A further extension of Shift_JIS to include NEC special characters (Row 13)
+                        csWindows31J { IANA } # A further extension of Shift_JIS to include NEC special characters (Row 13)
+                        x-sjis  # Probably MIME
+                        943
+                        # Iana says that Windows-31J is an extension to csshiftjis ibm-932 
+ibm-949_P110-2000 { UTR22* }
+                        ibm-949 { IBM* }
+                        ibm-949_VASCII_VSUB_VPUA
+
+ibm-949_P11A-2000 { UTR22* }
+                        ibm-949
                         ibm-949_VSUB_VPUA
                         KS_C_5601-1987 { IANA* }
                         iso-ir-149 { IANA }
@@ -341,25 +395,69 @@ ibm-949_P11A-2000
                         ksc5601_1992 # KSC-5601-1992
                         ksc5601_1987 # Needed by Java
 
-ibm-1370_P100-2000      ibm-1370 ibm-1370_VSUB_VPUA Big5 { IANA* MIME* } csBig5 x-big5 cp950 950 # Taiwan Big-5 (w/ euro update)
-ibm-950                 # Taiwan Big-5 (w/o euro update)
-ibm-1386_P100-2002      ibm-1386 ibm-1386_VSUB_VPUA gbk { IANA* } cp936 windows-936 ms936 zh_cn # Chinese GBK removed
+ibm-1370_P100-2000 { UTR22* }
+                        ibm-1370 { IBM* }
+                        ibm-1370_VSUB_VPUA
+                        Big5 { IANA* MIME* }
+                        csBig5 { IANA }
+                        x-big5
+                        cp950
+                        950 # Taiwan Big-5 (w/ euro update)
+ibm-950 { IBM* }        # Taiwan Big-5 (w/o euro update)
 
-ibm-33722_P120-2000     ibm-33722_VASCII_VPUA ibm-33722 cp33722 33722 ibm-5050 # Japan EUC with \ <-> Yen mapping
-ibm-33722_P12A-2000     ibm-33722_VPUA EUC-JP { MIME* } ibm-eucJP eucjis Extended_UNIX_Code_Packed_Format_for_Japanese { IANA* } cseucpkdfmtjapanese X-EUC-JP # Japan EUC. x-euc-jp is a MIME name
-ibm-970_P110-2000       ibm-970 ibm-970_VPUA EUC-KR { IANA* MIME* } ibm-eucKR csEUCKR  # Korean EUC. x-euc-kr is a MIME name
-ibm-964_P110-2000       ibm-964 ibm-964_VPUA EUC-TW ibm-eucTW cns11643 # Taiwan EUC. x-euc-tw is a MIME name
+ibm-1386_P100-2002  { UTR22* }
+                        ibm-1386 { IBM* }
+                        ibm-1386_VSUB_VPUA
+                        GBK { IANA* }
+                        CP936 { IANA }
+                        windows-936 { IANA }
+                        MS936 { IANA }
+                        zh_cn # Chinese GBK removed
 
-ibm-1363_P110-2000      ibm-1363 ibm-1363_VASCII_VSUB_VPUA ibm-1362 # Korean KSC Korean Windows MBCS 
+ibm-33722_P120-2000 { UTR22* } # Japan EUC with \ <-> Yen mapping
+                        ibm-33722 { IBM* }
+                        ibm-33722_VASCII_VPUA
+                        cp33722
+                        33722
+                        ibm-5050
+ibm-33722_P12A-2000 { UTR22* }
+                        ibm-33722 # Leave untagged because this isn't the default
+                        ibm-33722_VPUA
+                        EUC-JP { IANA MIME* }
+                        ibm-eucJP
+                        eucjis
+                        Extended_UNIX_Code_Packed_Format_for_Japanese { IANA* }
+                        csEUCPkdFmtJapanese { IANA }
+                        X-EUC-JP # Japan EUC. x-euc-jp is a MIME name
+ibm-970_P110-2000 { UTR22* }
+                        ibm-970 { IBM* }
+                        ibm-970_VPUA
+                        EUC-KR { IANA* MIME* }
+                        ibm-eucKR
+                        csEUCKR { IANA }  # Korean EUC. x-euc-kr is a MIME name
+ibm-964_P110-2000 { UTR22* }
+                        ibm-964 { IBM* }
+                        ibm-964_VPUA
+                        EUC-TW
+                        ibm-eucTW
+                        cns11643 # Taiwan EUC. x-euc-tw is a MIME name
 
-ibm-1363_P11B-2000      ibm-1363_VSUB_VPUA
+ibm-1363_P110-2000 { UTR22* } # Korean KSC Korean Windows MBCS 
+                        ibm-1363 { IBM* }
+                        ibm-1363_VASCII_VSUB_VPUA
+                        # ibm-1362 { IBM } # ibm-1362 is a DBCS codepage, not MBCS
+
+ibm-1363_P11B-2000 { UTR22* }
+                        ibm-1363 # Leave untagged because this isn't the default
+                        ibm-1363_VSUB_VPUA
                         windows-949
                         cp949
                         cp1363
                         ksc
                         # korean # The korean alias from IANA goes to ibm-949_P11A-2000
 
-ibm-1383_P110-2000      ibm-1383_VPUA
+ibm-1383_P110-2000 { UTR22* }
+                        ibm-1383_VPUA
                         ibm-1383
                         EUC-CN
                         ibm-eucCN
@@ -374,89 +472,89 @@ ibm-1383_P110-2000      ibm-1383_VPUA
                         1383
                         csGB2312    # China EUC. x-euc-cn is a MIME name
 
-ibm-1162                tis-620 { IANA* } cp874 windows-874 ms874 cp9066 874 # Thai (w/ euro update)
-ibm-874                 ibm-1161 # Same as 1162 (w/o euro update)
+ibm-1162 { IBM* }       TIS-620 { IANA* } cp874 windows-874 ms874 cp9066 874 # Thai (w/ euro update)
+ibm-874 { IBM* }        ibm-1161 # Same as 1162 (w/o euro update)
 
 # Platform codepages
-ibm-437                 cp437 csPC8CodePage437 437  # PC US
-ibm-850                 IBM850 { IANA* } cp850 { MIME* } 850 csPC850Multilingual    # PC latin1
-ibm-851                 IBM851 { IANA* } cp851 { MIME* } 851 csPC851            # PC DOS Greek (w/o euro)
-ibm-858                 cp858  { MIME* } IBM00858 { IANA* }       # PC latin1 with Euro cp850 removed
-ibm-9044                852 csPCp852 cp852  # PC latin2 (w/ euro update) cp852 is a MIME name for IBM-852
-ibm-852                 IBM852 { IANA* }    # PC latin2 (w/o euro update)
-ibm-872                 855 csIBM855 cp855 csPCp855 # PC cyrillic (w/ euro update) cp855 is a MIME name for IBM-855
-ibm-855                 IBM855 { IANA* }            # PC cyrillic (w/o euro update)
-ibm-856                 cp856 { MIME* }  856 # PC Hebrew (old)
-ibm-9049                857 csIBM857 cp857 { MIME* } # PC Latin 5 (Turkish) (w/ euro update)
-ibm-857                 IBM857 { IANA* }    # PC Latin 5 (w/o euro update)
-ibm-859                 cp859 { MIME* }     # PC Latin     9 (w/ euro update)
-ibm-860                 IBM860 { IANA* } cp860 { MIME* } 860 csIBM860         # PC Portugal
-ibm-861                 IBM861 { IANA* } cp861 { MIME* } 861 cp-is csIBM861   # PC Iceland
-ibm-867                 cp867  862 cp862 { MIME* } cspc862latinhebrew    # PC Hebrew (w/ euro update)
-ibm-862                 IBM862 { IANA* }                                 # PC Hebrew (w/o euro update)
-ibm-863                 IBM863 { IANA* } cp863 { MIME* } 863 csIBM863         # PC Canadian French
-ibm-17248               cp864 { MIME* } csIBM864 # PC Arabic (w/ euro update)
-ibm-864                 IBM864 { IANA* }         # PC Arabic (w/o euro update)
-ibm-865                 IBM865 { IANA* } cp865 { MIME* } 865 csIBM865         # PC Nordic
-ibm-808                 cp866 { MIME* } 866 csIBM866 # PC Russian (w/ euro update)
-ibm-866                                             # PC Russian (w/o euro update)
-ibm-868                 IBM868 { IANA* } cp868 { MIME* } cp-ar csIBM868 868   # PC Urdu
-ibm-9061                cp869 { MIME* } 869 cp-gr csIBM869   # PC Greek (w/ euro update)
-ibm-869                 IBM869 { IANA* }                     # PC Greek (w/o euro update)
-ibm-878                 KOI8-R { IANA* MIME* } cp878 koi8 cskoi8r  # Russian internet
-ibm-901                 cp921 { MIME* } 921 # PC Baltic (w/ euro update)
-ibm-921                                     # PC Baltic (w/o euro update)
-ibm-902                 cp922 { MIME* } 922 # PC Estonian (w/ euro update)
-ibm-922                                     # PC Estonian (w/o euro update)
+ibm-437 { IBM* }        cp437 csPC8CodePage437 437  # PC US
+ibm-850 { IBM* }        IBM850 { IANA* } cp850 { MIME* } 850 csPC850Multilingual    # PC latin1
+ibm-851 { IBM* }        IBM851 { IANA* } cp851 { MIME* } 851 csPC851            # PC DOS Greek (w/o euro)
+ibm-858 { IBM* }        cp858  { MIME* } IBM00858 { IANA* }       # PC latin1 with Euro cp850 removed
+ibm-9044 { IBM* }       852 csPCp852 cp852  # PC latin2 (w/ euro update) cp852 is a MIME name for IBM-852
+ibm-852 { IBM* }        IBM852 { IANA* }    # PC latin2 (w/o euro update)
+ibm-872 { IBM* }        855 csIBM855 cp855 csPCp855 # PC cyrillic (w/ euro update) cp855 is a MIME name for IBM-855
+ibm-855 { IBM* }        IBM855 { IANA* }            # PC cyrillic (w/o euro update)
+ibm-856 { IBM* }        cp856 { MIME* }  856 # PC Hebrew (old)
+ibm-9049 { IBM* }       857 csIBM857 cp857 { MIME* } # PC Latin 5 (Turkish) (w/ euro update)
+ibm-857 { IBM* }        IBM857 { IANA* }    # PC Latin 5 (w/o euro update)
+ibm-859 { IBM* }        cp859 { MIME* }     # PC Latin     9 (w/ euro update)
+ibm-860 { IBM* }        IBM860 { IANA* } cp860 { MIME* } 860 csIBM860         # PC Portugal
+ibm-861 { IBM* }        IBM861 { IANA* } cp861 { MIME* } 861 cp-is csIBM861   # PC Iceland
+ibm-867 { IBM* }        cp867  862 cp862 { MIME* } cspc862latinhebrew    # PC Hebrew (w/ euro update)
+ibm-862 { IBM* }        IBM862 { IANA* }                                 # PC Hebrew (w/o euro update)
+ibm-863 { IBM* }        IBM863 { IANA* } cp863 { MIME* } 863 csIBM863         # PC Canadian French
+ibm-17248 { IBM* }      cp864 { MIME* } csIBM864 # PC Arabic (w/ euro update)
+ibm-864 { IBM* }        IBM864 { IANA* }         # PC Arabic (w/o euro update)
+ibm-865 { IBM* }        IBM865 { IANA* } cp865 { MIME* } 865 csIBM865         # PC Nordic
+ibm-808 { IBM* }        cp866 { MIME* } 866 csIBM866 # PC Russian (w/ euro update)
+ibm-866 { IBM* }                                    # PC Russian (w/o euro update)
+ibm-868 { IBM* }        IBM868 { IANA* } cp868 { MIME* } cp-ar csIBM868 868   # PC Urdu
+ibm-9061 { IBM* }       cp869 { MIME* } 869 cp-gr csIBM869   # PC Greek (w/ euro update)
+ibm-869 { IBM* }       IBM869 { IANA* }                     # PC Greek (w/o euro update)
+ibm-878 { IBM* }        KOI8-R { IANA* MIME* } cp878 koi8 cskoi8r  # Russian internet
+ibm-901 { IBM* }        cp921 { MIME* } 921 # PC Baltic (w/ euro update)
+ibm-921 { IBM* }                            # PC Baltic (w/o euro update)
+ibm-902 { IBM* }        cp922 { MIME* } 922 # PC Estonian (w/ euro update)
+ibm-922 { IBM* }                            # PC Estonian (w/o euro update)
 # ibm-941                 jis-208 jisx-208    # Pure DBCS jisx-208 # ibm-941 is not JISX 208 code page
 
-ibm-5346                windows-1250 { IANA* } cp1250       # Windows Latin2 (w/ euro update)
-ibm-5347                windows-1251 { IANA* } cp1251       # Windows Cyrillic (w/ euro update)
-ibm-5348                windows-1252 { IANA* } cp1252       # Windows Latin1 (w/ euro update)
-ibm-5349                windows-1253 { IANA* } cp1253       # Windows Greek (w/ euro update)
-ibm-5350                windows-1254 { IANA* } cp1254       # Windows Turkish (w/ euro update)
-ibm-5351                windows-1255 { IANA* } cp1255       # Windows Hebrew (w/ euro update)
-ibm-5352                windows-1256 { IANA* } cp1256       # Windows Arabic (w/ euro update)
-ibm-5353                windows-1257 { IANA* } cp1257       # Windows Baltic (w/ euro update)
-ibm-5354                windows-1258 { IANA* } cp1258       # Windows Vietnamese (w/ euro update)
-ibm-1250                # Windows Latin2 (w/o euro update)
-ibm-1251                # Windows Cyrillic (w/o euro update)
-ibm-1253                # Windows Greek (w/o euro update)
-ibm-1254                # Windows Turkish (w/o euro update)
-ibm-1255                # Windows Hebrew (w/o euro update)
-ibm-1256                # Windows Arabic (w/o euro update)
-ibm-1257                # Windows Baltic (w/o euro update)
-ibm-1258                # Windows Vietnamese (w/o euro update)
+ibm-5346 { IBM* }       windows-1250 { IANA* } cp1250       # Windows Latin2 (w/ euro update)
+ibm-5347 { IBM* }       windows-1251 { IANA* } cp1251       # Windows Cyrillic (w/ euro update)
+ibm-5348 { IBM* }       windows-1252 { IANA* } cp1252       # Windows Latin1 (w/ euro update)
+ibm-5349 { IBM* }       windows-1253 { IANA* } cp1253       # Windows Greek (w/ euro update)
+ibm-5350 { IBM* }       windows-1254 { IANA* } cp1254       # Windows Turkish (w/ euro update)
+ibm-5351 { IBM* }       windows-1255 { IANA* } cp1255       # Windows Hebrew (w/ euro update)
+ibm-5352 { IBM* }       windows-1256 { IANA* } cp1256       # Windows Arabic (w/ euro update)
+ibm-5353 { IBM* }       windows-1257 { IANA* } cp1257       # Windows Baltic (w/ euro update)
+ibm-5354 { IBM* }       windows-1258 { IANA* } cp1258       # Windows Vietnamese (w/ euro update)
+ibm-1250 { IBM* }       # Windows Latin2 (w/o euro update)
+ibm-1251 { IBM* }       # Windows Cyrillic (w/o euro update)
+ibm-1253 { IBM* }       # Windows Greek (w/o euro update)
+ibm-1254 { IBM* }       # Windows Turkish (w/o euro update)
+ibm-1255 { IBM* }       # Windows Hebrew (w/o euro update)
+ibm-1256 { IBM* }       # Windows Arabic (w/o euro update)
+ibm-1257 { IBM* }       # Windows Baltic (w/o euro update)
+ibm-1258 { IBM* }       # Windows Vietnamese (w/o euro update)
 
-ibm-1275                macintosh { IANA* } mac { MIME* } csMacintosh # Apple latin 1
-ibm-1276                Adobe-Standard-Encoding { IANA* } csAdobeStandardEncoding # Different from ISO-Unicode-IBM-1276 (GCSGID: 1276)
-ibm-1277                Adobe-Latin1-Encoding
-ibm-1280                macgr                   # Apple Greek
-ibm-1281                mactr                   # Apple Turkish
-ibm-1282                macce                   # Apple Central Europe
-ibm-1283                maccy                   # Apple Cyrillic
+ibm-1275 { IBM* }       macintosh { IANA* } mac { IANA MIME* } csMacintosh { IANA } # Apple latin 1
+ibm-1276 { IBM* }       Adobe-Standard-Encoding { IANA* } csAdobeStandardEncoding { IANA } # Different from ISO-Unicode-IBM-1276 (GCSGID: 1276)
+ibm-1277 { IBM* }       Adobe-Latin1-Encoding
+ibm-1280 { IBM* }       macgr                   # Apple Greek
+ibm-1281 { IBM* }       mactr                   # Apple Turkish
+ibm-1282 { IBM* }       macce                   # Apple Central Europe
+ibm-1283 { IBM* }       maccy                   # Apple Cyrillic
 
-ibm-1051                hp-roman8 { IANA* } roman8 r8 csHPRoman8  # HP Latin1
+ibm-1051 { IBM* }       hp-roman8 { IANA* } roman8 r8 csHPRoman8  # HP Latin1
 
-ibm-806_P100-2000       ibm-806 ibm-806_VSUB    # PC ISCII-91: Indian Script Code
-ibm-1006_P100-2000      ibm-1006 ibm-1006_VPUA  # Urdu
-ibm-1006_X100-2000      ibm-1006_STD            # Urdu
-ibm-1098_P100-2000      ibm-1098 ibm-1098_VSUB_VPUA # Farsi
-ibm-1098_X100-2000      ibm-1098_VSUB           # Farsi
-ibm-1124_P100-2000      ibm-1124 ibm-1124_STD   # ISO Cyrillic Ukraine
-ibm-1125_P100-2000      ibm-1125 ibm-1125_VSUB  # Cyrillic Ukraine PC
-ibm-1129_P100-2000      ibm-1129 ibm-1129_STD   # ISO Vietnamese
-ibm-1131_P100-2000      ibm-1131 ibm-1131_VSUB  # Cyrillic Belarus PC
-ibm-1133_P100-2000      ibm-1133 ibm-1133_STD   # ISO Lao
-ibm-1381_P110-2000      ibm-1381 ibm-1381_VSUB_VPUA # S-Ch PC Data mixed (IBM GB) 
-ibm-9066_P100-2000      ibm-9066 ibm-9066_VSUB  # Thai PC
+ibm-806_P100-2000 { UTR22* }    ibm-806 { IBM* } ibm-806_VSUB    # PC ISCII-91: Indian Script Code
+ibm-1006_P100-2000 { UTR22* }   ibm-1006 { IBM* } ibm-1006_VPUA  # Urdu
+ibm-1006_X100-2000 { UTR22* }   ibm-1006_STD            # Urdu
+ibm-1098_P100-2000 { UTR22* }   ibm-1098 { IBM* } ibm-1098_VSUB_VPUA # Farsi
+ibm-1098_X100-2000 { UTR22* }   ibm-1098_VSUB           # Farsi
+ibm-1124_P100-2000 { UTR22* }   ibm-1124 { IBM* } ibm-1124_STD   # ISO Cyrillic Ukraine
+ibm-1125_P100-2000 { UTR22* }   ibm-1125 { IBM* } ibm-1125_VSUB  # Cyrillic Ukraine PC
+ibm-1129_P100-2000 { UTR22* }   ibm-112 { IBM* }9 ibm-1129_STD   # ISO Vietnamese
+ibm-1131_P100-2000 { UTR22* }   ibm-1131 { IBM* } ibm-1131_VSUB  # Cyrillic Belarus PC
+ibm-1133_P100-2000 { UTR22* }   ibm-1133 { IBM* } ibm-1133_STD   # ISO Lao
+ibm-1381_P110-2000 { UTR22* }   ibm-1381 { IBM* } ibm-1381_VSUB_VPUA # S-Ch PC Data mixed (IBM GB) 
+ibm-9066_P100-2000 { UTR22* }   ibm-9066 { IBM* } ibm-9066_VSUB  # Thai PC
 
 # Added for more euro support
 
-ibm-849                 cp1131          # PC     Belarus (w/ euro update)
-ibm-848                 cp1125          # PC     Ukraine (w/ euro update)
-ibm-5104                cp1008          # 8-bit Arabic (w/ euro update)
-ibm-9238                cp1046          # PC     Arabic Extended (w/ euro update)
+ibm-849 { IBM* }        cp1131          # PC     Belarus (w/ euro update)
+ibm-848 { IBM* }        cp1125          # PC     Ukraine (w/ euro update)
+ibm-5104 { IBM* }       cp1008          # 8-bit Arabic (w/ euro update)
+ibm-9238 { IBM* }       cp1046          # PC     Arabic Extended (w/ euro update)
 # ibm-5210                cp1114          # PC     SBCS Big-5 (w/ euro update)
 # ibm-21427               cp947           # PC     DBCS Big-5 (w/ euro update)
 
@@ -465,77 +563,87 @@ ibm-9238                cp1046          # PC     Arabic Extended (w/ euro update
 # EBCDIC codepages according to the CDRA
 
 # without Euro
-ibm-37                  IBM037 { IANA* } ibm-037 cpibm37 ebcdic-cp-us ebcdic-cp-ca ebcdic-cp-wt ebcdic-cp-nl csIBM037 cp37 cp037 037 # EBCDIC US
-ibm-273                 IBM273 { IANA* } csIBM273 ebcdic-de cp273 cpibm273 273 # EBCDIC Germanay, Austria
-ibm-277                 IBM277 { IANA* } EBCDIC-CP-DK EBCDIC-CP-NO csIBM277 ebcdic-dk cp277 cpibm277 277 # EBCDIC Denmark
-ibm-278                 IBM278 { IANA* } ebcdic-cp-fi ebcdic-cp-se csIBM278 ebcdic-sv cp278 cpibm278 278 # EBCDIC Sweden
-ibm-280                 IBM280 { IANA* } ebcdic-cp-it csIBM280 cp280 cpibm280 280 # EBCDIC Italy
-ibm-284                 IBM284 { IANA* } ebcdic-cp-es csIBM284 cp284 cpibm284 284 # EBCDIC Spain
-ibm-285                 IBM285 { IANA* } ebcdic-cp-gb csIBM285 ebcdic-gb cp285 cpibm285 285 # EBCDIC UK Ireland
-ibm-290                 IBM290 { IANA* } EBCDIC-JP-kana csIBM290 cp290 # host SBCS (Katakana)
-ibm-297                 IBM297 { IANA* } ebcdic-cp-fr csIBM297 cp297 cpibm297 297 # EBCDIC France
-ibm-420                 IBM420 { IANA* } ebcdic-cp-ar1 csIBM420 cp420 420
-ibm-424                 IBM424 { IANA* } ebcdic-cp-he csIBM424 cp424 424
-ibm-500                 IBM500 { IANA* } cpibm500 csIBM500 cp500 ebcdic-cp-be ebcdic-cp-ch 500 # EBCDIC International Latin1
-ibm-803                 cp803                # Old EBCDIC Hebrew
+ibm-37 { IBM* }         IBM037 { IANA* } # EBCDIC US
+                        ibm-037
+                        cpibm37
+                        ebcdic-cp-us { IANA }
+                        ebcdic-cp-ca { IANA }
+                        ebcdic-cp-wt { IANA }
+                        ebcdic-cp-nl { IANA }
+                        csIBM037 { IANA }
+                        cp37
+                        cp037
+                        037
+ibm-273 { IBM* }        IBM273 { IANA* } csIBM273 { IANA } ebcdic-de CP273 { IANA } cpibm273 273 # EBCDIC Germanay, Austria
+ibm-277 { IBM* }        IBM277 { IANA* } EBCDIC-CP-DK { IANA } EBCDIC-CP-NO { IANA } csIBM277 { IANA } ebcdic-dk cp277 cpibm277 277 # EBCDIC Denmark
+ibm-278 { IBM* }        IBM278 { IANA* } ebcdic-cp-fi { IANA } ebcdic-cp-se { IANA } csIBM278 { IANA } ebcdic-sv cp278 cpibm278 278 # EBCDIC Sweden
+ibm-280 { IBM* }        IBM280 { IANA* } ebcdic-cp-it { IANA } csIBM280 { IANA } CP280 { IANA } cpibm280 280 # EBCDIC Italy
+ibm-284 { IBM* }        IBM284 { IANA* } ebcdic-cp-es { IANA } csIBM284 { IANA } CP284 { IANA } cpibm284 284 # EBCDIC Spain
+ibm-285 { IBM* }        IBM285 { IANA* } ebcdic-cp-gb { IANA } csIBM285 { IANA } CP285 { IANA } ebcdic-gb cpibm285 285 # EBCDIC UK Ireland
+ibm-290 { IBM* }        IBM290 { IANA* } EBCDIC-JP-kana { IANA } csIBM290 { IANA } cp290 { IANA } # host SBCS (Katakana)
+ibm-297 { IBM* }        IBM297 { IANA* } ebcdic-cp-fr { IANA } csIBM297 { IANA } cp297 { IANA } cpibm297 297 # EBCDIC France
+ibm-420 { IBM* }        IBM420 { IANA* } ebcdic-cp-ar1 { IANA } csIBM420 { IANA } cp420 { IANA } 420
+ibm-424 { IBM* }        IBM424 { IANA* } ebcdic-cp-he { IANA } csIBM424 { IANA } cp424 { IANA } 424
+ibm-500 { IBM* }        IBM500 { IANA* } cpibm500 csIBM500 { IANA } CP500 { IANA } ebcdic-cp-be { IANA } ebcdic-cp-ch { IANA } 500 # EBCDIC International Latin1
+ibm-803 { IBM* }        cp803                # Old EBCDIC Hebrew
 #ibm-834                 cp834                # Korean DBCS Host (ibm-933 is the mixed host version of this codepage)
 #ibm-835                 cp835                # DBCS T-Ch Host (ibm-9027 is the Euro update of this codepage)
-ibm-870_P100-2000       IBM870 { IANA* } ibm-870 CP870 ibm-870_STD ebcdic-cp-roece ebcdic-cp-yu csIBM870
-ibm-871                 IBM871 { IANA* } ebcdic-cp-is csIBM871 cpibm871 cp871 871 # EBCDIC Iceland
-ibm-875_P100-2000       ibm-875 cp875 875 ibm-875_STD 
-ibm-918_P100-2000       IBM918 { IANA* } ibm-918 CP918 ibm-918_VPUA ebcdic-cp-ar2 csIBM918 
-ibm-918_X100-2000       ibm-918_STD
-ibm-930                 cp930 cpibm930 930 #ibm-5026 # EBCDIC_STATEFUL Katakana-Kanji Host Mixed. ibm-930 =? ibm-5026
-ibm-933                 cp933 cpibm933 933   # Korea EBCDIC MIXED 
-ibm-935                 cp935 cpibm935 935   # China EBCDIC MIXED 
-ibm-937                 cp937 cpibm937 937   # Taiwan EBCDIC MIXED
-ibm-939                 cp939 939 #ibm-5035   # EBCDIC_STATEFUL Latin-Kanji Host Mixed. ibm-939 =? ibm-5035
-ibm-1025_P100-2000      ibm-1025 ibm-1025_STD
-ibm-1026_P100-2000      IBM1026 { IANA* } ibm-1026 CP1026 csIBM1026 ibm-1026_STD
+ibm-870_P100-2000 { UTR22* }    IBM870 { IANA* } ibm-870 { IBM* } CP870 { IANA } ibm-870_STD ebcdic-cp-roece { IANA } ebcdic-cp-yu { IANA } csIBM870 { IANA }
+ibm-871 { IBM* }        IBM871 { IANA* } ebcdic-cp-is { IANA } csIBM871 { IANA } ebcdic-is cpibm871 CP871 { IANA } 871 # EBCDIC Iceland
+ibm-875_P100-2000 { UTR22* }    ibm-875 { IBM* } cp875 875 ibm-875_STD 
+ibm-918_P100-2000 { UTR22* }    IBM918 { IANA* } ibm-918 { IBM* } CP918 { IANA } ibm-918_VPUA ebcdic-cp-ar2 { IANA } csIBM918 { IANA }
+ibm-918_X100-2000 { UTR22* }    ibm-918_STD
+ibm-930 { IBM* }        cp930 cpibm930 930 #ibm-5026 # EBCDIC_STATEFUL Katakana-Kanji Host Mixed. ibm-930 =? ibm-5026
+ibm-933 { IBM* }        cp933 cpibm933 933   # Korea EBCDIC MIXED 
+ibm-935 { IBM* }        cp935 cpibm935 935   # China EBCDIC MIXED 
+ibm-937 { IBM* }        cp937 cpibm937 937   # Taiwan EBCDIC MIXED
+ibm-939 { IBM* }        cp939 939 #ibm-5035   # EBCDIC_STATEFUL Latin-Kanji Host Mixed. ibm-939 =? ibm-5035
+ibm-1025_P100-2000 { UTR22* }   ibm-1025 { IBM* } ibm-1025_STD
+ibm-1026_P100-2000 { UTR22* }   IBM1026 { IANA* } ibm-1026 { IBM* } CP1026 { IANA } csIBM1026 { IANA } ibm-1026_STD
 ibm-1047                cpibm1047            # EBCDIC Open systems Latin1
-ibm-1097_P100-2000      ibm-1097 ibm-1097_VPUA
-ibm-1097_X100-2000      ibm-1097_STD 
-ibm-1112_P100-2000      ibm-1112 cp1112 1112 ibm-1112_STD
-ibm-1122_P100-2000      ibm-1122 cp1122 1122 ibm-1122_STD
-ibm-1130_P100-2000      ibm-1130 ibm-1130_STD
-ibm-1132_P100-2000      ibm-1132 ibm-1132_STD
-ibm-1137_P100-2000      ibm-1137 ibm-1137_STD
-ibm-1388_P103-2001      ibm-1388             # S-Ch DBCS-Host Data GBK mixed MBCS
-ibm-9030_P100-2000      ibm-9030 ibm-9030_STD
+ibm-1097_P100-2000 { UTR22* }   ibm-1097 { IBM* } ibm-1097_VPUA
+ibm-1097_X100-2000 { UTR22* }   ibm-1097_STD 
+ibm-1112_P100-2000 { UTR22* }   ibm-1112 { IBM* } cp1112 1112 ibm-1112_STD
+ibm-1122_P100-2000 { UTR22* }   ibm-1122 { IBM* } cp1122 1122 ibm-1122_STD
+ibm-1130_P100-2000 { UTR22* }   ibm-1130 { IBM* } ibm-1130_STD
+ibm-1132_P100-2000 { UTR22* }   ibm-1132 { IBM* } ibm-1132_STD
+ibm-1137_P100-2000 { UTR22* }   ibm-1137 { IBM* } ibm-1137_STD
+ibm-1388_P103-2001 { UTR22* }   ibm-1388 { IBM* }             # S-Ch DBCS-Host Data GBK mixed MBCS
+ibm-9030_P100-2000 { UTR22* }   ibm-9030 { IBM* } ibm-9030_STD
 
 # with Euro
-ibm-1123                cpibm1123            # EBCDIC Cyrillic Ukraine
-ibm-1140                cpibm1140 IBM01140 { IANA* } # EBCDIC US
-ibm-1141                cpibm1141 IBM01141 { IANA* } # EBCDIC Germanay,   Austria
-ibm-1142                cpibm1142 IBM01142 { IANA* } # EBCDIC Denmark
-ibm-1143                cpibm1143 IBM01143 { IANA* } # EBCDIC Sweden
-ibm-1144                cpibm1144            # EBCDIC Italy
-ibm-1145                cpibm1145            # EBCDIC Spain
-ibm-1146                cpibm1146            # EBCDIC UK Ireland
-ibm-1147                cpibm1147            # EBCDIC France
-ibm-1148                cpibm1148            # EBCDIC International Latin1
-ibm-1149                cpibm1149 ebcdic-is  # EBCDIC Iceland
-ibm-1153                cpibm1153            # EBCDIC latin 2
-ibm-1154                cp1025 cpibm1154     # EBCDIC Cyrillic Multilingual
-ibm-1155                cpibm1155            # EBCDIC Turkey
-ibm-1156                cpibm1156            # EBCDIC Baltic Multilingual
-ibm-1157                cpibm1157            # EBCDIC Estonia
-ibm-1158                cp1123 cpibm1158 1123    # EBCDIC Cyrillic Ukraine
-ibm-1159                cp28709              # SBCS T-Ch Host
-ibm-1160                cp9030 cpibm1160     # EBCDIC Thailand
-ibm-1164                cp1130 cpibm1164     # EBCDIC Viet Nam
-ibm-1364_P110-2000      ibm-1364 ibm-1364_VPUA cp1364    # Korean Host Mixed
-ibm-1371                cpibm1371            # Taiwan EBCDIC MIXED
-ibm-1390                cpibm1390            # Japan EBCDIC MIXED
-ibm-1399                                     # Host MBCS (Latin-Kanji)
-ibm-4899                cpibm4899            # Old EBCDIC Hebrew
-ibm-4971                cpibm4971            # EBCDIC Greek
-ibm-5123                cp1027               # Host Roman Jis
-ibm-8482                                     # host SBCS (Katakana)
-ibm-9027                                     # DBCS T-Ch Host (simlar to ibm-835)
-ibm-12712               cpibm12712 ebcdic-he # EBCDIC Hebrew (new sheqel, control charaters update)
-ibm-16684               cp300                # DBCS Jis + Roman Jis Host
-ibm-16804               cpibm16804 ebcdic-ar # EBCDIC Arabic
+ibm-1123 { IBM* }       cpibm1123            # EBCDIC Cyrillic Ukraine
+ibm-1140 { IBM* }       cpibm1140 IBM01140 { IANA* } CCSID01140 { IANA } CP01140 { IANA } ebcdic-us-37+euro { IANA } # EBCDIC US
+ibm-1141 { IBM* }       cpibm1141 IBM01141 { IANA* } CCSID01141 { IANA } CP01141 { IANA } ebcdic-de-273+euro { IANA } # EBCDIC Germanay,   Austria
+ibm-1142 { IBM* }       cpibm1142 IBM01142 { IANA* } CCSID01142 { IANA } CP01142 { IANA } ebcdic-dk-277+euro { IANA } ebcdic-no-277+euro { IANA } # EBCDIC Denmark
+ibm-1143 { IBM* }       cpibm1143 IBM01143 { IANA* } CCSID01143 { IANA } CP01143 { IANA } ebcdic-fi-278+euro { IANA } ebcdic-se-278+euro { IANA } # EBCDIC Sweden
+ibm-1144 { IBM* }       cpibm1144 IBM01144 { IANA* } CCSID01144 { IANA } CP01144 { IANA } ebcdic-it-280+euro { IANA } # EBCDIC Italy
+ibm-1145 { IBM* }       cpibm1145 IBM01145 { IANA* } CCSID01145 { IANA } CP01145 { IANA } ebcdic-es-284+euro { IANA } # EBCDIC Spain
+ibm-1146 { IBM* }       cpibm1146 IBM01146 { IANA* } CCSID01146 { IANA } CP01146 { IANA } ebcdic-gb-285+euro { IANA } # EBCDIC UK Ireland
+ibm-1147 { IBM* }       cpibm1147 IBM01147 { IANA* } CCSID01147 { IANA } CP01147 { IANA } ebcdic-fr-297+euro { IANA } # EBCDIC France
+ibm-1148 { IBM* }       cpibm1148 IBM01148 { IANA* } CCSID01148 { IANA } CP01148 { IANA } ebcdic-international-500+euro { IANA } # EBCDIC International Latin1
+ibm-1149 { IBM* }       cpibm1149 IBM01149 { IANA* } CCSID01149 { IANA } CP01149 { IANA } ebcdic-is-871+euro { IANA } # EBCDIC Iceland
+ibm-1153 { IBM* }       cpibm1153            # EBCDIC latin 2
+ibm-1154 { IBM* }       cp1025 cpibm1154     # EBCDIC Cyrillic Multilingual
+ibm-1155 { IBM* }       cpibm1155            # EBCDIC Turkey
+ibm-1156 { IBM* }       cpibm1156            # EBCDIC Baltic Multilingual
+ibm-1157 { IBM* }       cpibm1157            # EBCDIC Estonia
+ibm-1158 { IBM* }       cp1123 cpibm1158 1123    # EBCDIC Cyrillic Ukraine
+ibm-1159 { IBM* }       cp28709              # SBCS T-Ch Host
+ibm-1160 { IBM* }       cp9030 cpibm1160     # EBCDIC Thailand
+ibm-1164 { IBM* }       cp1130 cpibm1164     # EBCDIC Viet Nam
+ibm-1364_P110-2000 { UTR22* }   ibm-1364 { IBM* } ibm-1364_VPUA cp1364    # Korean Host Mixed
+ibm-1371 { IBM* }       cpibm1371            # Taiwan EBCDIC MIXED
+ibm-1390 { IBM* }       cpibm1390            # Japan EBCDIC MIXED
+ibm-1399 { IBM* }                            # Host MBCS (Latin-Kanji)
+ibm-4899 { IBM* }       cpibm4899            # Old EBCDIC Hebrew
+ibm-4971 { IBM* }       cpibm4971            # EBCDIC Greek
+ibm-5123 { IBM* }       cp1027               # Host Roman Jis
+ibm-8482 { IBM* }                            # host SBCS (Katakana)
+ibm-9027 { IBM* }                            # DBCS T-Ch Host (simlar to ibm-835)
+ibm-12712 { IBM* }      cpibm12712 ebcdic-he # EBCDIC Hebrew (new sheqel, control charaters update)
+ibm-16684 { IBM* }      cp300                # DBCS Jis + Roman Jis Host
+ibm-16804 { IBM* }      cpibm16804 ebcdic-ar # EBCDIC Arabic
 
 # unsupported IANA names
 # ebcdic-it csEBCDICIT
@@ -547,21 +655,21 @@ ibm-16804               cpibm16804 ebcdic-ar # EBCDIC Arabic
 # EBCDIC codepages for S/390, with LF and NL codes swapped
 
 # without Euro
-ibm-37-s390             ibm037-s390   # EBCDIC US
-ibm-1047-s390           # EBCDIC for S/390 Open Edition
+ibm-37-s390 { UTR22* }    ibm037-s390   # EBCDIC US
+ibm-1047-s390 { UTR22* }    # EBCDIC for S/390 Open Edition
 
 # with Euro 
-ibm-1140-s390           # EBCDIC US
-ebcdic-xml-us           # Yet another form of ibm-1140
-ibm-1142-s390           # EBCDIC Denmark
-ibm-1143-s390           # EBCDIC Sweden
-ibm-1144-s390           # EBCDIC Italy
-ibm-1145-s390           # EBCDIC Spain
-ibm-1146-s390           # EBCDIC UK Ireland
-ibm-1147-s390           # EBCDIC France
-ibm-1148-s390           # EBCDIC International Latin1
-ibm-1149-s390           # EBCDIC Iceland
-ibm-1153-s390           # EBCDIC latin 2
-ibm-12712-s390          # EBCDIC Hebrew
-ibm-16804-s390          # EBCDIC Arabic
+ibm-1140-s390 { UTR22* }    # EBCDIC US
+ebcdic-xml-us               # Yet another form of ibm-1140
+ibm-1142-s390 { UTR22* }    # EBCDIC Denmark
+ibm-1143-s390 { UTR22* }    # EBCDIC Sweden
+ibm-1144-s390 { UTR22* }    # EBCDIC Italy
+ibm-1145-s390 { UTR22* }    # EBCDIC Spain
+ibm-1146-s390 { UTR22* }    # EBCDIC UK Ireland
+ibm-1147-s390 { UTR22* }    # EBCDIC France
+ibm-1148-s390 { UTR22* }    # EBCDIC International Latin1
+ibm-1149-s390 { UTR22* }    # EBCDIC Iceland
+ibm-1153-s390 { UTR22* }    # EBCDIC latin 2
+ibm-12712-s390 { UTR22* }   # EBCDIC Hebrew
+ibm-16804-s390 { UTR22* }   # EBCDIC Arabic
 
diff --git a/icu4c/source/test/cintltst/ccapitst.c b/icu4c/source/test/cintltst/ccapitst.c
index 7730d827139..4a67ff7f951 100644
--- a/icu4c/source/test/cintltst/ccapitst.c
+++ b/icu4c/source/test/cintltst/ccapitst.c
@@ -1048,12 +1048,18 @@ static void TestAlias() {
 
         alias0 = ucnv_getAlias(name, 0, &status);
         for (j=1; j<na; ++j) {
-            const char *alias = ucnv_getAlias(name, j, &status);
+            const char *alias;
             /* Make sure each alias maps back to the the same list of
                aliases.  Assume that if alias 0 is the same, the whole
                list is the same (this should always be true). */
             const char *mapBack;
 
+            status = U_ZERO_ERROR;
+            alias = ucnv_getAlias(name, j, &status);
+            if (status == U_AMBIGUOUS_ALIAS_WARNING) {
+                log_err("FAIL: Converter \"%s\"is ambiguous\n", name);
+            }
+
             if (alias == NULL) {
                 log_err("FAIL: Converter \"%s\" -> "
                         "alias[%d]=NULL\n",
@@ -1072,10 +1078,15 @@ static void TestAlias() {
             }
 
             if (0 != uprv_strcmp(alias0, mapBack)) {
-                log_err("FAIL: Converter \"%s\" -> "
-                        "alias[%d]=\"%s\" -> "
-                        "alias[0]=\"%s\", exp. \"%s\"\n",
-                        name, j, alias, mapBack, alias0);
+                if (status != U_AMBIGUOUS_ALIAS_WARNING) {
+                    log_err("FAIL: Converter \"%s\" -> "
+                            "alias[%d]=\"%s\" -> "
+                            "alias[0]=\"%s\", exp. \"%s\"\n",
+                            name, j, alias, mapBack, alias0);
+                }
+                else {
+                    ucnv_getAlias(mapBack, 0, &status);
+                }
             }
         }
     }
diff --git a/icu4c/source/test/cintltst/ncnvfbts.c b/icu4c/source/test/cintltst/ncnvfbts.c
index a4ff3ae321a..2774f46bdc3 100644
--- a/icu4c/source/test/cintltst/ncnvfbts.c
+++ b/icu4c/source/test/cintltst/ncnvfbts.c
@@ -124,7 +124,7 @@ static void setNuConvTestName(const char *codepage, const char *direction)
 
 
 static UBool testConvertFromUnicode(const UChar *source, int sourceLen,  const uint8_t *expect, int expectLen, 
-                const char *codepage, UBool fallback, int32_t *expectOffsets)
+                const char *codepage, UBool fallback, const int32_t *expectOffsets)
 {
 
 
@@ -287,7 +287,7 @@ static UBool testConvertFromUnicode(const UChar *source, int sourceLen,  const u
 }
 
 static UBool testConvertToUnicode( const uint8_t *source, int sourcelen, const UChar *expect, int expectlen, 
-               const char *codepage, UBool fallback, int32_t *expectOffsets)
+               const char *codepage, UBool fallback, const int32_t *expectOffsets)
 {
     UErrorCode status = U_ZERO_ERROR;
     UConverter *conv = 0;
@@ -450,43 +450,44 @@ static UBool testConvertToUnicode( const uint8_t *source, int sourcelen, const U
 static void TestConvertFallBackWithBufferSizes(int32_t outsize, int32_t insize ) 
 {
 
-    UChar    SBCSText[] = 
+    static const UChar    SBCSText[] = 
      { 0x0021, 0xFF01, 0x0022, 0xFF02, 0x0023, 0xFF03, 0x003A, 0xFF1A, 0x003B, 0xFF1B, 0x003C, 0xFF1C };
      /* 21, ?, 22, ?, 23, ?, 3a, ?, 3b, ?, 3c, ? SBCS*/
-    const uint8_t expectedNative[] = 
+    static const uint8_t expectedNative[] = 
      {  0x21, 0x21, 0x22, 0x22, 0x23, 0x23, 0x3a, 0x3a, 0x3b, 0x3b, 0x3c, 0x3c};
-    UChar retrievedSBCSText[]=
+    static const UChar retrievedSBCSText[]=
        { 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023, 0x003A, 0x003A, 0x003B, 0x003B, 0x003C, 0x003C };
-    int32_t  toNativeOffs    [] = 
+    static const int32_t  toNativeOffs    [] = 
      {  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b};
-    int32_t fromNativeoffs []  = 
+    static const int32_t fromNativeoffs []  = 
     {  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
    
     
-    UChar    DBCSText[] = 
+    /* 1363 isn't DBCS, but it has the DBCS section */
+    static const UChar    DBCSText[] = 
      { 0x00a1, 0x00ad, 0x2010, 0x00b7, 0x30fb};
-    const uint8_t expectedIBM1362[] = 
+    static const uint8_t expectedIBM1363_DBCS[] = 
      {  0xa2, 0xae, 0xa1 ,0xa9, 0xa1, 0xa9,0xa1 ,0xa4, 0xa1, 0xa4};
-    UChar retrievedDBCSText[]=
+    static const UChar retrievedDBCSText[]=
         { 0x00a1, 0x2010, 0x2010, 0x30fb, 0x30fb };
-    int32_t  toIBM1362Offs    [] = 
+    static const int32_t  toIBM1363Offs_DBCS[] = 
         {  0x00, 0x00, 0x01,0x01, 0x02, 0x02,  0x03, 0x03, 0x04, 0x04};
-    int32_t fromIBM1362offs []  = 
+    static const int32_t fromIBM1363offs_DBCS[]  = 
     {  0, 2, 4, 6, 8};
 
 
-    UChar    MBCSText[] = 
+    static const UChar    MBCSText[] = 
      { 0x0001, 0x263a, 0x2013, 0x2014, 0x263b, 0x0002};
-    const uint8_t expectedIBM1370[] = 
+    static const  uint8_t expectedIBM1370[] = 
      {  0x01, 0x01, 0xa1, 0x56, 0xa1, 0x56, 0x02, 0x02};
-    UChar retrievedMBCSText[]=
+    static const UChar retrievedMBCSText[]=
        { 0x0001, 0x0001, 0x2014, 0x2014, 0x0002, 0x0002};
-    int32_t  toIBM1370Offs    [] = 
+    static const int32_t  toIBM1370Offs    [] = 
      {  0x00, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05};
-    int32_t fromIBM1370offs []  = 
+    static const int32_t fromIBM1370offs []  = 
     {  0, 1, 2, 4, 6, 7};
 
-    UChar    MBCSText1363[] = 
+    static const UChar    MBCSText1363[] = 
      { 0x0005, 
        0xffe8, 
        0x0007, 
@@ -496,7 +497,7 @@ static void TestConvertFallBackWithBufferSizes(int32_t outsize, int32_t insize )
        0x3016, 
        0x30fb, 
        0x9a36};
-    const uint8_t expectedIBM1363[] = 
+    static const uint8_t expectedIBM1363[] = 
      {  0x05, 
         0x05, 
         0x07, 
@@ -506,16 +507,16 @@ static void TestConvertFallBackWithBufferSizes(int32_t outsize, int32_t insize )
         0xa1, 0xe0, 
         0xa1, 0xa4, 
         0xf5, 0xe2};
-    UChar retrievedMBCSText1363[]=
+    static const UChar retrievedMBCSText1363[]=
        { 0x0005, 0x0005, 0x0007, 0x0007, 0x001a,  0x30fb, 0x25a1, 0x30fb, 0x9a36};
-    int32_t  toIBM1363Offs    [] = 
+    static const int32_t  toIBM1363Offs    [] = 
      {  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08};
-    int32_t fromIBM1363offs []  = 
+    static const int32_t fromIBM1363offs []  = 
     {  0, 1, 2, 3, 4, 5, 7, 9, 11};
 
 
     
-    const char* nativeCodePage[]={
+    static const char* nativeCodePage[]={
         /*NLCS Mapping*/
         "ibm-367",
         "ibm-1051",
@@ -549,12 +550,12 @@ static void TestConvertFallBackWithBufferSizes(int32_t outsize, int32_t insize )
     
     /*DBCS*/
     if(!testConvertFromUnicode(DBCSText, sizeof(DBCSText)/sizeof(DBCSText[0]),
-        expectedIBM1362, sizeof(expectedIBM1362), "ibm-1362", TRUE, toIBM1362Offs ))
-       log_err("u-> ibm-1362(DBCS) with FallBack did not match.\n");
+        expectedIBM1363_DBCS, sizeof(expectedIBM1363_DBCS), "ibm-1363", TRUE, toIBM1363Offs_DBCS ))
+       log_err("u-> ibm-1363(DBCS portion) with FallBack did not match.\n");
 
-    if(!testConvertToUnicode(expectedIBM1362, sizeof(expectedIBM1362), 
-        retrievedDBCSText, sizeof(retrievedDBCSText)/sizeof(retrievedDBCSText[0]),"ibm-1362", TRUE, fromIBM1362offs ))
-        log_err("ibm-1362->u(DBCS) with Fallback did not match.\n");
+    if(!testConvertToUnicode(expectedIBM1363_DBCS, sizeof(expectedIBM1363_DBCS), 
+        retrievedDBCSText, sizeof(retrievedDBCSText)/sizeof(retrievedDBCSText[0]),"ibm-1363", TRUE, fromIBM1363offs_DBCS ))
+        log_err("ibm-1363->u(DBCS portion) with Fallback did not match.\n");
 
   
     /*MBCS*/
diff --git a/icu4c/source/test/cintltst/ncnvfbts.h b/icu4c/source/test/cintltst/ncnvfbts.h
index 369cc76dc15..a47e141ccfc 100644
--- a/icu4c/source/test/cintltst/ncnvfbts.h
+++ b/icu4c/source/test/cintltst/ncnvfbts.h
@@ -21,9 +21,9 @@
 static void TestConverterFallBack(void);
 static void TestConvertFallBackWithBufferSizes(int32_t outsize, int32_t insize );
 static UBool testConvertFromUnicode(const UChar *source, int sourceLen,  const uint8_t *expect, int expectLen, 
-                const char *codepage, UBool fallback, int32_t *expectOffsets);
+                const char *codepage, UBool fallback, const int32_t *expectOffsets);
 static UBool testConvertToUnicode( const uint8_t *source, int sourcelen, const UChar *expect, int expectlen, 
-               const char *codepage, UBool fallback, int32_t *expectOffsets);
+               const char *codepage, UBool fallback, const int32_t *expectOffsets);
 
 
 static void printSeq(const unsigned char* a, int len);
diff --git a/icu4c/source/test/cintltst/ncnvtst.c b/icu4c/source/test/cintltst/ncnvtst.c
index 2a85bc4327b..646b8edb33d 100644
--- a/icu4c/source/test/cintltst/ncnvtst.c
+++ b/icu4c/source/test/cintltst/ncnvtst.c
@@ -147,11 +147,11 @@ static void TestSurrogateBehaviour(){
 
         /*DBCS*/
         if(!convertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
-                expected, sizeof(expected), "ibm-1362", 0 , TRUE, U_ZERO_ERROR))
-            log_err("u-> ibm-1362 [UCNV_DBCS] not match.\n");
+                expected, sizeof(expected), "ibm-1363", 0 , TRUE, U_ZERO_ERROR))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] not match.\n");
         if(!convertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
-                expected, sizeof(expected), "ibm-1362", offsets , TRUE, U_ZERO_ERROR))
-            log_err("u-> ibm-1362 [UCNV_DBCS] not match.\n");
+                expected, sizeof(expected), "ibm-1363", offsets , TRUE, U_ZERO_ERROR))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] not match.\n");
         /*MBCS*/
         if(!convertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
                 expected, sizeof(expected), "ibm-1363", 0 , TRUE, U_ZERO_ERROR))
@@ -367,26 +367,26 @@ static void TestErrorBehaviour(){
 
         /*DBCS*/
         if(!convertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
-                expected, sizeof(expected), "ibm-1362", 0, TRUE, U_TRUNCATED_CHAR_FOUND))
-            log_err("u-> ibm-1362 [UCNV_DBCS] is supposed to fail\n");
+                expected, sizeof(expected), "ibm-1363", 0, TRUE, U_TRUNCATED_CHAR_FOUND))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] is supposed to fail\n");
         if(!convertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
-                expected, sizeof(expected), "ibm-1362", 0, FALSE, U_ZERO_ERROR))
-            log_err("u-> ibm-1362 [UCNV_DBCS] is supposed to fail\n");
+                expected, sizeof(expected), "ibm-1363", 0, FALSE, U_ZERO_ERROR))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] is supposed to fail\n");
 
         if(!convertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
-                expected, sizeof(expected), "ibm-1362", offsets, TRUE, U_TRUNCATED_CHAR_FOUND))
-            log_err("u-> ibm-1362 [UCNV_DBCS] is supposed to fail\n");
+                expected, sizeof(expected), "ibm-1363", offsets, TRUE, U_TRUNCATED_CHAR_FOUND))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] is supposed to fail\n");
         if(!convertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
-                expected, sizeof(expected), "ibm-1362", offsets, FALSE, U_ZERO_ERROR))
-            log_err("u-> ibm-1362 [UCNV_DBCS] is supposed to fail\n");
+                expected, sizeof(expected), "ibm-1363", offsets, FALSE, U_ZERO_ERROR))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] is supposed to fail\n");
 
         
         if(!convertFromU(sampleText2, sizeof(sampleText2)/sizeof(sampleText2[0]),
-                expected2, sizeof(expected2), "ibm-1362", 0, TRUE, U_ZERO_ERROR))
-            log_err("u-> ibm-1362 [UCNV_DBCS] did not match \n");
+                expected2, sizeof(expected2), "ibm-1363", 0, TRUE, U_ZERO_ERROR))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] did not match \n");
         if(!convertFromU(sampleText2, sizeof(sampleText2)/sizeof(sampleText2[0]),
-                expected2, sizeof(expected2), "ibm-1362", offsets2, TRUE, U_ZERO_ERROR))
-            log_err("u-> ibm-1362 [UCNV_DBCS] did not match \n");
+                expected2, sizeof(expected2), "ibm-1363", offsets2, TRUE, U_ZERO_ERROR))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] did not match \n");
 
         /*MBCS*/
         if(!convertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
@@ -637,15 +637,15 @@ static void TestToUnicodeErrorBehaviour()
         const UChar expected2[] = { 0x00a1 };
 
         if(!convertToU(sampleText, sizeof(sampleText), 
-                expected, sizeof(expected)/sizeof(expected[0]), "ibm-1362", 0, TRUE, U_ZERO_ERROR ))
-            log_err("DBCS (ibm-1362)->Unicode  did not match.\n");
+                expected, sizeof(expected)/sizeof(expected[0]), "ibm-1363", 0, TRUE, U_ZERO_ERROR ))
+            log_err("DBCS (ibm-1363)->Unicode  did not match.\n");
         if(!convertToU(sampleText, sizeof(sampleText), 
-                expected, sizeof(expected)/sizeof(expected[0]), "ibm-1362", 0, FALSE, U_ZERO_ERROR ))
-            log_err("DBCS (ibm-1362)->Unicode  with flush = false did not match.\n");
+                expected, sizeof(expected)/sizeof(expected[0]), "ibm-1363", 0, FALSE, U_ZERO_ERROR ))
+            log_err("DBCS (ibm-1363)->Unicode  with flush = false did not match.\n");
        
         if(!convertToU(sampleText2, sizeof(sampleText2), 
-                expected2, sizeof(expected2)/sizeof(expected2[0]), "ibm-1362", 0, TRUE, U_TRUNCATED_CHAR_FOUND ))
-            log_err("DBCS (ibm-1362)->Unicode with TRUNCATED CHARACTER  did not match.\n");
+                expected2, sizeof(expected2)/sizeof(expected2[0]), "ibm-1363", 0, TRUE, U_TRUNCATED_CHAR_FOUND ))
+            log_err("DBCS (ibm-1363)->Unicode with TRUNCATED CHARACTER  did not match.\n");
        
     
     }
@@ -1480,16 +1480,16 @@ static void TestResetBehaviour(void){
 
         /*DBCS*/
         if(!testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
-                expected, sizeof(expected), "ibm-1362", UCNV_FROM_U_CALLBACK_SUBSTITUTE , NULL, TRUE))
-            log_err("u-> ibm-1362 [UCNV_DBCS] not match.\n");
+                expected, sizeof(expected), "ibm-1363", UCNV_FROM_U_CALLBACK_SUBSTITUTE , NULL, TRUE))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] not match.\n");
         if(!testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
-                expected, sizeof(expected), "ibm-1362", UCNV_FROM_U_CALLBACK_SUBSTITUTE,offsets , TRUE))
-            log_err("u-> ibm-1362 [UCNV_DBCS] not match.\n");
+                expected, sizeof(expected), "ibm-1363", UCNV_FROM_U_CALLBACK_SUBSTITUTE,offsets , TRUE))
+            log_err("u-> ibm-1363 [UCNV_DBCS portion] not match.\n");
        
         if(!testConvertToU(expected1, sizeof(expected1), 
-                sampleText1, sizeof(sampleText1)/sizeof(sampleText1[0]), "ibm-1362",UCNV_TO_U_CALLBACK_SUBSTITUTE , 
+                sampleText1, sizeof(sampleText1)/sizeof(sampleText1[0]), "ibm-1363",UCNV_TO_U_CALLBACK_SUBSTITUTE , 
                 offsets1, TRUE))
-           log_err("ibm-1362 -> did not match.\n");
+           log_err("ibm-1363 -> did not match.\n");
         /*MBCS*/
         if(!testConvertFromU(sampleText, sizeof(sampleText)/sizeof(sampleText[0]),
                 expected, sizeof(expected), "ibm-1363", UCNV_FROM_U_CALLBACK_SUBSTITUTE , NULL, TRUE))
diff --git a/icu4c/source/tools/gencnval/gencnval.c b/icu4c/source/tools/gencnval/gencnval.c
index bf975a54b60..29bf75299ae 100644
--- a/icu4c/source/tools/gencnval/gencnval.c
+++ b/icu4c/source/tools/gencnval/gencnval.c
@@ -70,7 +70,6 @@
 #define ALL_TAG_STR "ALL"
 #define ALL_TAG_NUM 1
 #define EMPTY_TAG_NUM 0
-#define USER_TAG_NUM_START 2
 
 /* UDataInfo cf. udata.h */
 static const UDataInfo dataInfo={
@@ -561,7 +560,7 @@ addOfficialTaggedStandards(char *line, int32_t lineLen) {
     uint16_t tagSize;
     static const char WHITESPACE[] = " \t";
 
-    if (tagCount > USER_TAG_NUM_START) {
+    if (tagCount > UCNV_NUM_RESERVED_TAGS) {
         fprintf(stderr, "error(line %d): official tags already added\n", lineNum);
         exit(U_BUFFER_OVERFLOW_ERROR);
     }
@@ -756,7 +755,7 @@ static void
 resolveAliasToConverter(uint16_t alias, uint16_t *tagNum, uint16_t *converterNum) {
     uint16_t idx, idx2, idx3;
 
-    for (idx = USER_TAG_NUM_START; idx < tagCount; idx++) {
+    for (idx = UCNV_NUM_RESERVED_TAGS; idx < tagCount; idx++) {
         for (idx2 = 0; idx2 < converterCount; idx2++) {
             for (idx3 = 0; idx3 < tags[idx].aliasList[idx2].aliasCount; idx3++) {
                 uint16_t aliasNum = tags[idx].aliasList[idx2].aliases[idx3];
@@ -794,7 +793,7 @@ resolveAliases(uint16_t *uniqueAliasArr, uint16_t *uniqueAliasToConverterArr, ui
     uint32_t uniqueAliasIdx = 0;
     uint32_t idx;
     uint16_t currTagNum, oldTagNum;
-    uint16_t currConvNum;
+    uint16_t currConvNum, oldConvNum;
     const char *lastName;
 
     resolveAliasToConverter(knownAliases[0], &oldTagNum, &currConvNum);
@@ -807,7 +806,8 @@ resolveAliases(uint16_t *uniqueAliasArr, uint16_t *uniqueAliasToConverterArr, ui
         resolveAliasToConverter(knownAliases[idx], &currTagNum, &currConvNum);
         if (ucnv_compareNames(lastName, GET_ALIAS_STR(knownAliases[idx])) == 0) {
             /* duplicate found */
-            if (currTagNum > oldTagNum) {
+            if ((currTagNum < oldTagNum && currTagNum >= UCNV_NUM_RESERVED_TAGS)
+                || oldTagNum == 0) {
                 oldTagNum = currTagNum;
                 uniqueAliasToConverterArr[uniqueAliasIdx - 1] = currConvNum;
                 uniqueAliasArr[uniqueAliasIdx - 1] = knownAliases[idx] + aliasOffset;
@@ -816,7 +816,7 @@ resolveAliases(uint16_t *uniqueAliasArr, uint16_t *uniqueAliasToConverterArr, ui
                         GET_ALIAS_STR(knownAliases[idx]),
                         lastName,
                         GET_ALIAS_STR(converters[currConvNum].converter));
-                    if (uniqueAliasToConverterArr[uniqueAliasIdx - 1] != currConvNum) {
+                    if (oldConvNum != currConvNum) {
                         printf(" (alias conflict)");
                     }
                     puts("");
@@ -828,22 +828,24 @@ resolveAliases(uint16_t *uniqueAliasArr, uint16_t *uniqueAliasToConverterArr, ui
                     printf("folding %s into %s -> %s",
                         GET_ALIAS_STR(knownAliases[idx]),
                         lastName,
-                        GET_ALIAS_STR(converters[currConvNum].converter));
-                    if (uniqueAliasToConverterArr[uniqueAliasIdx - 1] != currConvNum) {
+                        GET_ALIAS_STR(converters[oldConvNum].converter));
+                    if (oldConvNum != currConvNum) {
                         printf(" (alias conflict)");
                     }
                     puts("");
                 }
             }
-            if (uniqueAliasToConverterArr[uniqueAliasIdx - 1] != currConvNum) {
+            if (oldConvNum != currConvNum) {
                 uniqueAliasToConverterArr[uniqueAliasIdx - 1] |= UCNV_AMBIGUOUS_ALIAS_MAP_BIT;
             }
         }
         else {
             uniqueAliasToConverterArr[uniqueAliasIdx] = currConvNum;
+            oldConvNum = currConvNum;
             uniqueAliasArr[uniqueAliasIdx] = knownAliases[idx] + aliasOffset;
             uniqueAliasIdx++;
             lastName = GET_ALIAS_STR(knownAliases[idx]);
+            oldTagNum = currTagNum;
             /*printf("%s -> %s\n", GET_ALIAS_STR(knownAliases[idx]), GET_ALIAS_STR(converters[currConvNum].converter));*/
         }
     }
@@ -935,7 +937,7 @@ writeAliasTable(UNewDataMemory *out) {
 
     /* write the table of tags */
     /* Think of this as the row headers */
-    for(i=USER_TAG_NUM_START; i<tagCount; ++i) {
+    for(i=UCNV_NUM_RESERVED_TAGS; i<tagCount; ++i) {
         udata_write16(out, tags[i].tag);
     }
     /* The empty tag is considered the leftover list, and put that at the end of the priority list. */