Add some questions; sample config in YAML.

NOTES.md

@@ -5,6 +5,9 @@
 The `.cfg` format seems to follow a INI-like syntax that is ad-hoc-parsed by
 the Transliterator.
 
+Unicode points are expressed as `U+????` rather than `\x????` of the standard
+INI syntax.
+
 So far only top-level section names have been encountered.
 
 Key-value pairs may express either a transliteration operation, e.g.
@@ -31,27 +34,44 @@ transliteration sections.
 It is unclear how configuration directives can be distinguished from
 transliteration rules, except by naming all the possible verbatim copy options.
 A more readable and efficent format would have discrete subsections for
-configuration and transliteration; if possible, vebatim copy should be
-implicit, which would make maintenance easier.
+configuration and transliteration—if necessary, with configuration and mapping
+subsections inside S2R and R2S sections.
+
+Q: Is it possible to copy non-mapped characters verbatim in script to Roman?
+That would remove the need to explicitly add English phrases to the S2R section
+such as `publisher not identified=publisher not identified`.
 
-It is unclear at the moment if spaces around the `=` sign are ignored.
+Q: Shall spaces around the `=` sign be ignored?
 
+Q: What are the `_` at the end of some mappings, e.g. `U+4E00=yi_` for Chinese?
+Are they supposed to add a space where the underscore appears?
 
 ## `ReRomanizeRecord.bas`
 
 Much of the code deals with MARC records. No need to concern about that since
 the new Transliterator is meant to convert text strings to text strings.
 
+Q: Is it possible (and desirable) to determine the S2R/R2S direction from user
+prompt rather than guessing it from the text as the legacy software seems to
+be doing?
+
+Q: The software seems to take multi-line directives in the configuration into
+account. Is it possible to avoid these for simplicity, or is there a need to
+express some mapping in multiple lines?
+
+Detailed breakdown of individual functions follows.
+
+
 ### Functions
 
-#### ReRomanizeText
+#### `ReRomanizeText`
 
 - Determine direction (input param): R2S or S2R
 - Determine personal name handling
 - Whether to uppercase first word
 
 
-#### LoadOneRomanizationTable
+#### `LoadOneRomanizationTable`
 
 Load cfg file (line by line, we can do the whole thing) and parse table
 metadata.
@@ -100,28 +120,128 @@ Likely irrelevant keywords:
 - Subfield6Code
 - SubfieldsAlwaysExcluded
 
-If no keyword is detected, proceed to transliteration. [TODO transliteration
-logic details still to be looked at]
+If no keyword is detected, proceed to transliteration.
 
 
 ##### `ScriptToRoman` section
 
 The logic is the same as the `RomanToscript` section, but the configuration
-keyword are different.
+keywords are different.
 
 Currently supported, potentially relevant:
 
  - UppercaseFirstCharacterInSubfield [TODO verify]
  - PersonalNameHandling
 
- Likely irrelevant:
+ Likely irrelevant (MARC-related):
 
  - CreateEmptyFields
  - FieldsIncluded
  - SubfieldsAlwaysExcluded
  - OtherSubfieldsExcludedByTag
 
-[TODO Complete other function analysis]
+There is some code (deactivated) to dump the whole table.
+
+
+#### `RomanizeConvertText`
+
+This gets called at several points by `ReRomanizeText`.
+
+It accepts `in`, supposedly the input text, a UTF8MarcRecordClass (probably the
+transliteration table) and a UTF8CharClass (?).
+
+It replaces `"_"` with `" "` within the transliteration table (so values with
+`_` are adding spaces to the translitrated text.
+
+It loops through the text and detects the following leaders: 
+
+There is a `LocalMarcRecordObject.SafeStuff()` function that seems critical but
+I can't seem to find a definition for it.
+
+There is a select switch within a loop whose function is not entirely clear. Is
+it to advance through sections of the text by MARC record internal markers?
+
+```
+Select Case sLeader$
+    Case "&H"
+        sLeader$ = "U+"
+    Case "U+"
+        sLeader$ = "&x"
+    Case "&x"
+        sLeader$ = "&X"
+    Case "&X"
+        sLeader$ = "&h"
+    Case "&h"
+        Exit Do
+End Select
+```
+
+
+#### `LoadRomanizationTables`
+
+This function seems to load all the tables by calling
+`LoadOneRomanizationTable` over a list of files.
+
+
+#### `ReRomanizeTextDetails`
+
+This is the logic of the romanization process by character or syllable.
+
+- Proceed by syllable or by character based on config (note: currently there
+    doesn't seem to be any cfg file containing the `BySyllables` option)
+- Decide to allow case variation based on config
+- Proceed scanning the text and looping; look for MARC delimiters
+  - Define initial only, terminal only, medial only characters
+  - Decide whether to translate R2V or V2R
+
+
+#### `EvaluateFirstCharacter`
+
+This determines if the translation is R2V or V2R. Does this work reliably and
+independently of any external directive? Could there be some strings in foreign
+scripts that start with Latin characters (e.g. numbers or Western terms), and
+lead to unexpected results?
+
+(Also the translation is supposedly purpose-driven, as the user should have a
+specific direction in mind and wouldn't want the software to decide for them.)
+
+
+#### `ReRomanizeTextDetailsReplaceApostrophes`
+
+Replace apostrophe characters with glyphs supported by foeign script?
+
+
+#### Field- and UI-related functions
+
+- `RomanizationAssistance`
+- `FindFieldCurrentlyPointedTo`
+- `RomanizationAssistanceConvertWholeRecord`
+- `ReRomanizeAdjustNonfilingIndicators`
+- `AddCharSetCodes2Utf8Record`
+- `FindScriptByKeyPress`
+- `IsFontInstalled`
+
+These functions seem to deal with interface interaction, field/text selection,
+and RTF clenaup. Probably very little to nothing needs to be carried over.
+
+Question: do we need to keep any formatting of the original text? And if yes,
+which formatting tags are allowed? (in an HTML UI the formatting could be in
+HTML or Markdown, so this may need to be taken into account.)
+
+Q: It seems like several characters are parsed and added to the text to denote
+MARC markers. Do we need to deal with these manually as indicators related to
+the script/language handled, or shall we expect any text string input in the
+new Transliterator to be clean from MARC flags? 
+
+#### `RomanizeConvertDecimalChars`
+
+Convert escape sequences `&#\d{4,5}` to code points.
+
+#### `CreateRomanizationScriptList`
+
+Create list of romanization script options by reading a master file. This will
+likely be replaced by a glob-like approach.
+
 
 ## General strategy for rewrite
 
@@ -178,7 +298,7 @@ server start. This should be auth-protected.
 
 `POST /reload_config`
 
-##### Authantication
+##### Authentication
 
 API token (probably just a hard-coded value in a .env file should suffice)
 
@@ -190,7 +310,7 @@ API token (probably just a hard-coded value in a .env file should suffice)
 
 ### Functional approach
 
-1. Load all translation table metadata on server startup. This is equivalent
+1. Upon server startup: load all translation table metadata. This is equivalent
    to invoking `reload_config` via REST API (see above) and is done by
    scanning a designated directory containing only the translation table,
    finding the metadata in the `General` section, disccovering the

data/ChineseRomanization.yml

@@ -0,0 +1,4577 @@
+general: # Section names and other keywords are all snake_cased.
+  name: Chinese
+  #allow_define_button: true # Probably not a relevant section.
+
+# roman_to_script: Empty section removed.
+
+script_to_roman:
+  directives: # Directives section.
+    # Irrelevant settings removed.
+    #fields_included: 100 110 111 130 240 245 246 250 260 264 440 490 505 600 610 611 630 651 700 710 711 730 740 800 830
+    #subfields_always_excluded: uvxy0123456789
+    #other_subfields_excluded_by_tag: 100/e 110/e 111/j 246/i 260/c 264/c 650/a 700/e 700/i 710/e 710/i 711/i 711/j 730/i
+    #uppercase_first_character_in_subfield: 260/b
+    personal_name_handling: true
+  map: # Mapping section.
+    # RDA boilerplate phrases not transliterated.
+    # All characters not found in the mapping are copid verbatim. No need for
+    # a "copy verbatim" section.
+    #Place of publication not identified=Place of publication not identified_
+    #publisher not identified=publisher not identified_
+
+    ## Begin Script2Roman Dictionary ##
+    # Q: Separate whole names from the rest? We'll see when we implement the
+    # logic maybe.
+    "\u4E2D\u56FD": Zhongguo_
+    "\u5317\u4EAC": Beijing_
+
+    # Single syllable transliteration.
+    "\u2018": "'"
+    "\u2019": "'"
+    "\u201C": "\""
+    "\u201D": "\""
+    "\u3000": 
+    "\u3001": ", " # Underscores are replaced by spaces directly in config.
+    "\u3002": ". "
+    "\u3007": "ling "
+    "\u3008": "\""
+    "\u3009": "\" "
+    "\u300A": "\""
+    "\u300B": "\" "
+    "\u300C": "\""
+    "\u300D": "\" "
+    "\u30FB": 
+    "\u4E00": "yi "
+    "\u4E01": "ding "
+    "\u4E03": "qi "
+    "\u4E07": "wan "
+    "\u4E08": "zhang "
+    "\u4E09": "san "
+    "\u4E0A": "shang "
+    "\u4E0B": "xia "
+    "\u4E0D": "bu "
+    "\u4E0E": "yu "
+    "\u4E10": "gai "
+    "\u4E11": "chou "
+    "\u4E13": "zhuan "
+    "\u4E14": "qie "
+    "\u4E15": "pi "
+    "\u4E16": "shi "
+    "\u4E18": "qiu "
+    "\u4E19": "bing "
+    "\u4E1A": "ye "
+    "\u4E1B": "cong "
+    "\u4E1C": "dong "
+    "\u4E1D": "si "
+    "\u4E22": "diu "
+    "\u4E24": "liang "
+    "\u4E25": "yan "
+    "\u4E26": "bing "
+    "\u4E27": "sang "
+    "\u4E2A": "ge "
+    "\u4E2B": "ya "
+    "\u4E2D": "zhong "
+    "\u4E30": "feng "
+    "\u4E32": "chuan "
+    "\u4E34": "lin "
+    "\u4E39": "dan "
+    "\u4E3A": "wei "
+    "\u4E3B": "zhu "
+    "\u4E3D": "li "
+    "\u4E3E": "ju "
+    "\u4E43": "nai "
+    "\u4E45": "jiu "
+    "\u4E48": "me "
+    "\u4E49": "yi "
+    "\u4E4B": "zhi "
+    "\u4E4C": "wu "
+    "\u4E4E": "hu "
+    "\u4E4F": "fa "
+    "\u4E50": "le "
+    "\u4E52": "ping "
+    "\u4E53": "pang "
+    "\u4E54": "qiao "
+    "\u4E56": "guai "
+    "\u4E58": "cheng "
+    "\u4E59": "yi "
+    "\u4E5D": "jiu "
+    "\u4E5F": "ye "
+    "\u4E60": "xi "
+    "\u4E61": "xiang "
+    "\u4E66": "shu "
+    "\u4E70": "mai "
+    "\u4E71": "luan "
+    "\u4E73": "ru "
+    "\u4E7E": "qian "
+    "\u4E82": "luan "
+    "\u4E86": "le "
+    "\u4E88": "yu "
+    "\u4E89": "zheng "
+    "\u4E8B": "shi "
+    "\u4E8C": "er "
+    "\u4E8E": "yu "
+    "\u4E8F": "kui "
+    "\u4E91": "yun "
+    "\u4E92": "hu "
+    "\u4E94": "wu "
+    "\u4E95": "jing "
+    "\u4E9A": "ya "
+    "\u4E9B": "xie "
+    "\u4E9C": "ya "
+    "\u4E9E": "ya "
+    "\u4EA1": "wang "
+    "\u4EA2": "kang "
+    "\u4EA4": "jiao "
+    "\u4EA5": "hai "
+    "\u4EA6": "yi "
+    "\u4EA7": "chan "
+    "\u4EA8": "heng "
+    "\u4EA9": "mu "
+    "\u4EAB": "xiang "
+    "\u4EAC": "jing "
+    "\u4EAD": "ting "
+    "\u4EAE": "liang "
+    "\u4EB2": "qin "
+    "\u4EBA": "ren "
+    "\u4EBF": "yi "
+    "\u4EC0": "shen "
+    "\u4EC1": "ren "
+    "\u4EC3": "Ding "
+    "\u4EC5": "jin "
+    "\u4EC6": "pu "
+    "\u4EC7": "chou "
+    "\u4ECA": "jin "
+    "\u4ECB": "jie "
+    "\u4ECD": "reng "
+    "\u4ECE": "cong "
+    "\u4ED1": "lun "
+    "\u4ED3": "cang "
+    "\u4ED4": "zi "
+    "\u4ED5": "shi "
+    "\u4ED6": "ta "
+    "\u4ED7": "zhang "
+    "\u4ED8": "fu "
+    "\u4ED9": "xian "
+    "\u4EDF": "qian "
+    "\u4EE3": "dai "
+    "\u4EE4": "ling "
+    "\u4EE5": "yi "
+    "\u4EEA": "yi "
+    "\u4EEC": "men "
+    "\u4EF0": "yang "
+    "\u4EF2": "zhong "
+    "\u4EF5": "Wu "
+    "\u4EF6": "jian "
+    "\u4EF7": "jia "
+    "\u4EFB": "ren "
+    "\u4EFD": "fen "
+    "\u4EFF": "fang "
+    "\u4F01": "qi "
+    "\u4F09": "Kang "
+    "\u4F0A": "yi "
+    "\u4F0D": "wu "
+    "\u4F0F": "fu "
+    "\u4F10": "fa "
+    "\u4F11": "xiu "
+    "\u4F15": "fu "
+    "\u4F17": "zhong "
+    "\u4F18": "you "
+    "\u4F19": "huo "
+    "\u4F1A": "hui "
+    "\u4F1F": "wei "
+    "\u4F20": "chuan "
+    "\u4F24": "shang "
+    "\u4F26": "lun "
+    "\u4F2A": "wei "
+    "\u4F2F": "bo "
+    "\u4F30": "gu "
+    "\u4F34": "ban "
+    "\u4F36": "ling "
+    "\u4F38": "shen "
+    "\u4F3C": "si "
+    "\u4F3D": "jia "
+    "\u4F43": "Dian "
+    "\u4F46": "dan "
+    "\u4F48": "bu "
+    "\u4F4D": "wei "
+    "\u4F4E": "di "
+    "\u4F4F": "zhu "
+    "\u4F50": "zuo "
+    "\u4F51": "you "
+    "\u4F53": "ti "
+    "\u4F55": "he "
+    "\u4F58": "she "
+    "\u4F59": "yu "
+    "\u4F5A": "yi "
+    "\u4F5B": "Fo "
+    "\u4F5C": "zuo "
+    "\u4F5F": "tong "
+    "\u4F60": "ni "
+    "\u4F64": "wa "
+    "\u4F69": "pei "
+    "\u4F70": "bai "
+    "\u4F73": "jia "
+    "\u4F75": "bing "
+    "\u4F76": "ji "
+    "\u4F7F": "shi "
+    "\u4F83": "kan "
+    "\u4F84": "zhi "
+    "\u4F86": "lai "
+    "\u4F8B": "li "
+    "\u4F8D": "shi "
+    "\u4F97": "dong "
+    "\u4F98": "cha "
+    "\u4F9B": "gong "
+    "\u4F9D": "yi "
+    "\u4FA0": "xia "
+    "\u4FA6": "zhen "
+    "\u4FA7": "ce "
+    "\u4FA8": "qiao "
+    "\u4FAF": "hou "
+    "\u4FB5": "qin "
+    "\u4FB6": "lu "
+    "\u4FBF": "bian "
+    "\u4FC2": "xi "
+    "\u4FC3": "cu "
+    "\u4FC4": "e "
+    "\u4FCA": "jun "
+    "\u4FCF": "Qiao "
+    "\u4FD0": "Li "
+    "\u4FD1": "yong "
+    "\u4FD7": "su "
+    "\u4FD8": "fu "
+    "\u4FDD": "bao "
+    "\u4FDE": "shu "
+    "\u4FE1": "xin "
+    "\u4FE9": "lia "
+    "\u4FED": "jian "
+    "\u4FEE": "xiu "
+    "\u4FEF": "fu "
+    "\u4FF1": "ju "
+    "\u4FFA": "an "
+    "\u5009": "cang "
+    "\u500B": "ge "
+    "\u500C": "guan "
+    "\u500D": "bei "
+    "\u5011": "men "
+    "\u5012": "dao "
+    "\u5013": "Tan "
+    "\u5018": "tang "
+    "\u5019": "hou "
+    "\u501A": "Yi "
+    "\u501F": "jie "
+    "\u5021": "chang "
+    "\u5026": "juan "
+    "\u5029": "qian "
+    "\u502A": "ni "
+    "\u502B": "lun "
+    "\u502C": "zhuo "
+    "\u503A": "zhai "
+    "\u503C": "zhi "
+    "\u503E": "qing "
+    "\u5047": "jia "
+    "\u5048": "jie "
+    "\u5049": "Wei "
+    "\u504E": "wei "
+    "\u504F": "pian "
+    "\u5055": "xie "
+    "\u505A": "zuo "
+    "\u505C": "ting "
+    "\u5065": "jian "
+    "\u5074": "ce "
+    "\u5075": "zhen "
+    "\u5076": "ou "
+    "\u5077": "tou "
+    "\u507D": "wei "
+    "\u507F": "chang "
+    "\u5085": "fu "
+    "\u5088": "Li "
+    "\u508D": "bang "
+    "\u5091": "jie "
+    "\u5098": "San "
+    "\u5099": "bei "
+    "\u50A2": "jia "
+    "\u50A3": "Dai "
+    "\u50A8": "chu "
+    "\u50AC": "cui "
+    "\u50B2": "ao "
+    "\u50B3": "zhuan "
+    "\u50B5": "zhai "
+    "\u50B7": "shang "
+    "\u50BB": "sha "
+    "\u50BE": "qing "
+    "\u50CF": "xiang "
+    "\u50D1": "qiao "
+    "\u50DA": "liao "
+    "\u50E7": "seng "
+    "\u50F1": "gu "
+    "\u50F3": "su "
+    "\u50F9": "jia "
+    "\u5100": "yi "
+    "\u5104": "yi "
+    "\u5109": "jian "
+    "\u510B": "Dan "
+    "\u5112": "ru "
+    "\u5115": "ji "
+    "\u511F": "chang "
+    "\u512A": "you "
+    "\u5132": "chu "
+    "\u513C": "Yan "
+    "\u513F": "er "
+    "\u5141": "yun "
+    "\u5143": "yuan "
+    "\u5144": "xiong "
+    "\u5145": "chong "
+    "\u5146": "zhao "
+    "\u5147": "xiong "
+    "\u5148": "xian "
+    "\u5149": "guang "
+    "\u514B": "ke "
+    "\u514C": "dui "
+    "\u514D": "mian "
+    "\u5151": "dui "
+    "\u5152": "er "
+    "\u5154": "Tu "
+    "\u5156": "yan "
+    "\u5157": "yan "
+    "\u515A": "dang "
+    "\u515C": "dou "
+    "\u5162": "jin "
+    "\u5165": "ru "
+    "\u5167": "nei "
+    "\u5168": "quan "
+    "\u5169": "Liang "
+    "\u516B": "ba "
+    "\u516C": "gong "
+    "\u516D": "liu "
+    "\u5170": "lan "
+    "\u5171": "gong "
+    "\u5173": "guan "
+    "\u5174": "xing "
+    "\u5175": "bing "
+    "\u5176": "qi "
+    "\u5177": "ju "
+    "\u5178": "dian "
+    "\u5179": "ci "
+    "\u517B": "yang "
+    "\u517C": "jian "
+    "\u517D": "shou "
+    "\u5180": "ji "
+    "\u5185": "nei "
+    "\u5188": "gang "
+    "\u5189": "Ran "
+    "\u518A": "ce "
+    "\u518C": "ce "
+    "\u518D": "zai "
+    "\u5192": "mao "
+    "\u5195": "mian "
+    "\u5199": "xie "
+    "\u519B": "jun "
+    "\u519C": "nong "
+    "\u51A0": "guan "
+    "\u51A2": "zhong "
+    "\u51A4": "yuan "
+    "\u51A5": "ming "
+    "\u51AC": "dong "
+    "\u51AF": "ping "
+    "\u51B0": "bing "
+    "\u51B2": "chong "
+    "\u51B3": "jue "
+    "\u51B5": "kuang "
+    "\u51B6": "ye "
+    "\u51B7": "leng "
+    "\u51BB": "dong "
+    "\u51BC": "xian "
+    "\u51C0": "jing "
+    "\u51C4": "qi "
+    "\u51C6": "zhun "
+    "\u51C9": "liang "
+    "\u51CC": "ling "
+    "\u51CF": "jian "
+    "\u51D1": "cou "
+    "\u51D6": "zhun "
+    "\u51DD": "ning "
+    "\u51E0": "ji "
+    "\u51E1": "fan "
+    "\u51E4": "feng "
+    "\u51ED": "ping "
+    "\u51EF": "kai "
+    "\u51F0": "huang "
+    "\u51F1": "kai "
+    "\u51F6": "xiong "
+    "\u51F9": "wa "
+    "\u51FA": "chu "
+    "\u51FB": "ji "
+    "\u51FD": "han "
+    "\u51FF": "Zao "
+    "\u5200": "dao "
+    "\u5201": "diao "
+    "\u5203": "ren "
+    "\u5206": "fen "
+    "\u5207": "qie "
+    "\u520A": "kan "
+    "\u520B": "kan "
+    "\u5211": "xing "
+    "\u5212": "hua "
+    "\u5217": "lie "
+    "\u5218": "Liu "
+    "\u5219": "ze "
+    "\u521A": "gang "
+    "\u521B": "chuang "
+    "\u521D": "chu "
+    "\u5224": "pan "
+    "\u5225": "bie "
+    "\u5229": "li "
+    "\u522B": "bie "
+    "\u522E": "gua "
+    "\u5230": "dao "
+    "\u5236": "zhi "
+    "\u5237": "shua "
+    "\u5238": "quan "
+    "\u5239": "sha "
+    "\u523A": "ci "
+    "\u523B": "ke "
+    "\u5242": "ji "
+    "\u5247": "ze "
+    "\u524A": "xue "
+    "\u524D": "qian "
+    "\u5251": "jian "
+    "\u5256": "pou "
+    "\u525B": "gang "
+    "\u5265": "bao "
+    "\u5267": "ju "
+    "\u5269": "sheng "
+    "\u526A": "jian "
+    "\u526F": "fu "
+    "\u5272": "ge "
+    "\u5275": "chuang "
+    "\u527F": "jiao "
+    "\u5283": "hua "
+    "\u5287": "ju "
+    "\u5288": "pi "
+    "\u5289": "Liu "
+    "\u528D": "jian "
+    "\u5291": "ji "
+    "\u529B": "li "
+    "\u529D": "quan "
+    "\u529E": "ban "
+    "\u529F": "gong "
+    "\u52A0": "jia "
+    "\u52A1": "wu "
+    "\u52A3": "lie "
+    "\u52A8": "dong "
+    "\u52A9": "zhu "
+    "\u52AA": "nu "
+    "\u52AB": "jie "
+    "\u52AD": "Shao "
+    "\u52B1": "li "
+    "\u52B2": "jin "
+    "\u52B3": "lao "
+    "\u52BF": "shi "
+    "\u52C1": "Jing "
+    "\u52C3": "bo "
+    "\u52C7": "yong "
+    "\u52C9": "mian "
+    "\u52CB": "xun "
+    "\u52D2": "lei "
+    "\u52D5": "dong "
+    "\u52D8": "kan "
+    "\u52D9": "wu "
+    "\u52DB": "xun "
+    "\u52DD": "sheng "
+    "\u52DE": "lao "
+    "\u52E2": "shi "
+    "\u52E4": "qin "
+    "\u52E6": "jiao "
+    "\u52F0": "xie "
+    "\u52F1": "mai "
+    "\u52F2": "xun "
+    "\u52F3": "xun "
+    "\u52F5": "li "
+    "\u52F8": "quan "
+    "\u52FA": "shao "
+    "\u52FE": "gou "
+    "\u5300": "yun "
+    "\u5305": "bao "
+    "\u5306": "cong "
+    "\u5315": "Bi "
+    "\u5316": "hua "
+    "\u5317": "bei "
+    "\u5320": "jiang "
+    "\u5321": "Kuang "
+    "\u532A": "fei "
+    "\u532F": "hui "
+    "\u5339": "pi "
+    "\u533A": "qu "
+    "\u533B": "yi "
+    "\u533E": "bian "
+    "\u533F": "ni "
+    "\u5340": "qu "
+    "\u5341": "shi "
+    "\u5343": "qian "
+    "\u5347": "sheng "
+    "\u5348": "wu "
+    "\u5349": "hui "
+    "\u534A": "ban "
+    "\u534E": "hua "
+    "\u534F": "xie "
+    "\u5351": "bei "
+    "\u5353": "zhuo "
+    "\u5354": "xie "
+    "\u5355": "dan "
+    "\u5356": "mai "
+    "\u5357": "nan "
+    "\u535A": "bo "
+    "\u535C": "bu "
+    "\u535E": "bian "
+    "\u5360": "zhan "
+    "\u5361": "ka "
+    "\u5362": "Lu "
+    "\u5367": "wo "
+    "\u536B": "wei "
+    "\u536F": "mao "
+    "\u5370": "yin "
+    "\u5371": "wei "
+    "\u5373": "ji "
+    "\u5374": "que "
+    "\u5375": "luan "
+    "\u5377": "juan "
+    "\u537B": "que "
+    "\u537F": "qing "
+    "\u5382": "chang "
+    "\u5385": "ting "
+    "\u5386": "li "
+    "\u5389": "li "
+    "\u538B": "ya "
+    "\u538C": "yan "
+    "\u5395": "ce "
+    "\u539A": "hou "
+    "\u539D": "cuo "
+    "\u539F": "yuan "
+    "\u53A2": "xiang "
+    "\u53A5": "jue "
+    "\u53A6": "sha "
+    "\u53A8": "chu "
+    "\u53B0": "chang "
+    "\u53B2": "li "
+    "\u53BB": "qu "
+    "\u53BF": "xian "
+    "\u53C1": "san "
+    "\u53C2": "can "
+    "\u53C3": "can "
+    "\u53C8": "you "
+    "\u53C9": "cha "
+    "\u53CA": "ji "
+    "\u53CB": "you "
+    "\u53CC": "shuang "
+    "\u53CD": "fan "
+    "\u53D1": "fa "
+    "\u53D4": "shu "
+    "\u53D6": "qu "
+    "\u53D7": "shou "
+    "\u53D8": "bian "
+    "\u53D9": "xu "
+    "\u53DB": "pan "
+    "\u53DF": "sou "
+    "\u53E0": "die "
+    "\u53E2": "cong "
+    "\u53E3": "kou "
+    "\u53E4": "gu "
+    "\u53E5": "ju "
+    "\u53E6": "ling "
+    "\u53EA": "zhi "
+    "\u53EB": "jiao "
+    "\u53EC": "zhao "
+    "\u53ED": "ba "
+    "\u53EE": "ding "
+    "\u53EF": "ke "
+    "\u53F0": "tai "
+    "\u53F2": "shi "
+    "\u53F3": "you "
+    "\u53F6": "ye "
+    "\u53F7": "hao "
+    "\u53F8": "si "
+    "\u53F9": "tan "
+    "\u5401": "yu "
+    "\u5403": "chi "
+    "\u5404": "ge "
+    "\u5408": "he "
+    "\u5409": "ji "
+    "\u540A": "diao "
+    "\u540C": "tong "
+    "\u540D": "ming "
+    "\u540E": "hou "
+    "\u540F": "Li "
+    "\u5410": "tu "
+    "\u5411": "xiang "
+    "\u5412": "zha "
+    "\u5413": "xia "
+    "\u5415": "Lu "
+    "\u5417": "ma "
+    "\u541B": "jun "
+    "\u541E": "tun "
+    "\u541F": "yin "
+    "\u5426": "fou "
+    "\u5427": "ba "
+    "\u5428": "dun "
+    "\u5429": "fen "
+    "\u542B": "han "
+    "\u542C": "ting "
+    "\u542F": "qi "
+    "\u5433": "wu "
+    "\u5434": "Wu "
+    "\u5435": "chao "
+    "\u5438": "xi "
+    "\u5439": "chui "
+    "\u543B": "wen "
+    "\u543C": "hou "
+    "\u543E": "wu "
+    "\u5440": "ya "
+    "\u5442": "lv "
+    "\u5446": "dai "
+    "\u5448": "cheng "
+    "\u5449": "Wu "
+    "\u544A": "gao "
+    "\u5458": "yuan "
+    "\u5462": "ne "
+    "\u5468": "zhou "
+    "\u5473": "wei "
+    "\u5475": "he "
+    "\u5477": "xia "
+    "\u547C": "hu "
+    "\u547D": "ming "
+    "\u548C": "he "
+    "\u548F": "yong "
+    "\u5490": "fu "
+    "\u5496": "ka "
+    "\u54A8": "zi "
+    "\u54AA": "mi "
+    "\u54AC": "yao "
+    "\u54B1": "zan "
+    "\u54B8": "xian "
+    "\u54BD": "yan "
+    "\u54C0": "ai "
+    "\u54C1": "pin "
+    "\u54C4": "hong "
+    "\u54C7": "wa "
+    "\u54C8": "ha "
+    "\u54C9": "zai "
+    "\u54CD": "xiang "
+    "\u54D1": "ya "
+    "\u54D7": "hua "
+    "\u54DF": "yo "
+    "\u54E1": "yuan "
+    "\u54E5": "ge "
+    "\u54E9": "li "
+    "\u54EA": "na "
+    "\u54ED": "ku "
+    "\u54F2": "zhe "
+    "\u54FA": "bu "
+    "\u54FC": "heng "
+    "\u5507": "chun "
+    "\u5509": "ai "
+    "\u5510": "tang "
+    "\u5524": "huan "
+    "\u552E": "shou "
+    "\u552F": "wei "
+    "\u5531": "chang "
+    "\u5546": "shang "
+    "\u554A": "a "
+    "\u554F": "wen "
+    "\u5553": "qi "
+    "\u555A": "tu "
+    "\u555F": "Qi "
+    "\u5561": "fei "
+    "\u5565": "sha "
+    "\u5566": "la "
+    "\u5578": "Xiao "
+    "\u5582": "wei "
+    "\u5583": "Nan "
+    "\u5584": "shan "
+    "\u5586": "Zhe "
+    "\u5587": "la "
+    "\u5588": "jie "
+    "\u5589": "hou "
+    "\u558A": "han "
+    "\u5598": "chuan "
+    "\u559C": "xi "
+    "\u559D": "he "
+    "\u55AC": "qiao "
+    "\u55AE": "dan "
+    "\u55B7": "pen "
+    "\u55BB": "Yu "
+    "\u55CE": "ma "
+    "\u55D3": "sang "
+    "\u55DC": "shi "
+    "\u55E3": "si "
+    "\u55EF": "EEKEEKg "
+    "\u55F7": "Ao "
+    "\u5609": "jia "
+    "\u560E": "ga "
+    "\u5617": "chang "
+    "\u561B": "ma "
+    "\u562F": "xiao "
+    "\u5631": "zhu "
+    "\u5632": "chao "
+    "\u5634": "zui "
+    "\u563B": "xi "
+    "\u563F": "hei "
+    "\u5668": "qi "
+    "\u566D": "jiao "
+    "\u5676": "Ga "
+    "\u5680": "ning "
+    "\u568F": "ti "
+    "\u56AE": "xiang "
+    "\u56B4": "yan "
+    "\u56B7": "rang "
+    "\u56CA": "nang "
+    "\u56D8": "hui "
+    "\u56DB": "si "
+    "\u56DE": "hui "
+    "\u56E0": "yin "
+    "\u56E2": "tuan "
+    "\u56ED": "yuan "
+    "\u56EF": "guo "
+    "\u56F0": "kun "
+    "\u56F4": "wei "
+    "\u56FA": "gu "
+    "\u56FD": "guo "
+    "\u56FE": "tu "
+    "\u5703": "pu "
+    "\u5706": "yuan "
+    "\u5708": "quan "
+    "\u570B": "guo "
+    "\u570D": "wei "
+    "\u5712": "yuan "
+    "\u5713": "yuan "
+    "\u5716": "tu "
+    "\u5718": "tuan "
+    "\u571F": "tu "
+    "\u5723": "sheng "
+    "\u5728": "zai "
+    "\u5729": "xu "
+    "\u572D": "Gui "
+    "\u5730": "di "
+    "\u5733": "zhen "
+    "\u573A": "chang "
+    "\u573B": "qi "
+    "\u573E": "ji "
+    "\u5740": "zhi "
+    "\u5742": "ban "
+    "\u5747": "jun "
+    "\u574A": "fang "
+    "\u574E": "kan "
+    "\u574F": "huai "
+    "\u5750": "zuo "
+    "\u5751": "keng "
+    "\u5757": "kuai "
+    "\u575A": "jian "
+    "\u575B": "tan "
+    "\u575D": "ba "
+    "\u575F": "fen "
+    "\u5761": "po "
+    "\u5764": "kun "
+    "\u5766": "tan "
+    "\u576A": "ping "
+    "\u577B": "chi "
+    "\u5782": "chui "
+    "\u5784": "long "
+    "\u578B": "xing "
+    "\u5792": "lei "
+    "\u57A3": "yuan "
+    "\u57A6": "ken "
+    "\u57AE": "Kua "
+    "\u57C3": "ai "
+    "\u57CB": "mai "
+    "\u57CE": "cheng "
+    "\u57D4": "pu "
+    "\u57DF": "yu "
+    "\u57E0": "bu "
+    "\u57ED": "dai "
+    "\u57F7": "zhi "
+    "\u57F9": "pei "
+    "\u57FA": "ji "
+    "\u5802": "tang "
+    "\u5803": "kun "
+    "\u5805": "jian "
+    "\u5806": "dui "
+    "\u5821": "bao "
+    "\u5824": "di "
+    "\u582A": "kan "
+    "\u582F": "yao "
+    "\u5830": "yan "
+    "\u5831": "bao "
+    "\u5834": "chang "
+    "\u5835": "du "
+    "\u584A": "kuai "
+    "\u584C": "ta "
+    "\u5851": "su "
+    "\u5854": "ta "
+    "\u5857": "tu "
+    "\u5858": "tang "
+    "\u585E": "sai "
+    "\u5864": "xun "
+    "\u586B": "tian "
+    "\u5872": "chang "
+    "\u5875": "chen "
+    "\u5880": "chi "
+    "\u5883": "jing "
+    "\u5885": "shu "
+    "\u5889": "yong "
+    "\u5893": "mu "
+    "\u5899": "qiang "
+    "\u589E": "zeng "
+    "\u589F": "xu "
+    "\u58A3": "pu "
+    "\u58A8": "mo "
+    "\u58A9": "dun "
+    "\u58B3": "fen "
+    "\u58BE": "ken "
+    "\u58C1": "bi "
+    "\u58C7": "tan "
+    "\u58D3": "ya "
+    "\u58E4": "rang "
+    "\u58EB": "shi "
+    "\u58EE": "zhuang "
+    "\u58F0": "sheng "
+    "\u58F3": "ke "
+    "\u58F6": "hu "
+    "\u58F9": "yi "
+    "\u58FA": "hu "
+    "\u58FD": "shou "
+    "\u5904": "chu "
+    "\u5907": "bei "
+    "\u590D": "fu "
+    "\u590F": "xia "
+    "\u5911": "xie "
+    "\u5915": "xi "
+    "\u5916": "wai "
+    "\u5919": "su "
+    "\u591A": "duo "
+    "\u591C": "ye "
+    "\u591F": "gou "
+    "\u5922": "meng xun "
+    "\u5927": "da "
+    "\u5929": "tian "
+    "\u592A": "tai "
+    "\u592B": "fu "
+    "\u592E": "yang "
+    "\u5931": "shi "
+    "\u5932": "ben "
+    "\u5934": "tou "
+    "\u5937": "yi "
+    "\u5938": "kua "
+    "\u5939": "jia "
+    "\u593A": "duo "
+    "\u5942": "huan "
+    "\u5947": "qi "
+    "\u5948": "nai "
+    "\u5949": "feng "
+    "\u594B": "fen "
+    "\u594E": "kui "
+    "\u594F": "zou "
+    "\u5950": "Huan "
+    "\u5951": "qi "
+    "\u5954": "ben "
+    "\u5955": "Yi "
+    "\u5956": "jiang "
+    "\u5957": "tao "
+    "\u5958": "zang "
+    "\u595A": "Xi "
+    "\u5960": "dian "
+    "\u5962": "she "
+    "\u5965": "ao "
+    "\u5967": "ao "
+    "\u596A": "duo "
+    "\u596C": "jiang "
+    "\u596E": "fen "
+    "\u5973": "nu "
+    "\u5974": "nu "
+    "\u5976": "nai "
+    "\u5978": "jian "
+    "\u5979": "ta "
+    "\u597D": "hao "
+    "\u5982": "ru "
+    "\u5983": "fei "
+    "\u5984": "wang "
+    "\u5986": "zhuang "
+    "\u5987": "fu "
+    "\u5988": "ma "
+    "\u5993": "ji "
+    "\u5996": "yao "
+    "\u5999": "miao "
+    "\u599D": "zhuang "
+    "\u59A4": "yu "
+    "\u59A5": "tuo "
+    "\u59A8": "fang "
+    "\u59AE": "ni "
+    "\u59B3": "ni "
+    "\u59B9": "mei "
+    "\u59BB": "qi "
+    "\u59C6": "mu "
+    "\u59CA": "zi "
+    "\u59CB": "shi "
+    "\u59D0": "jie "
+    "\u59D1": "gu "
+    "\u59D2": "Si "
+    "\u59D3": "xing "
+    "\u59D4": "wei "
+    "\u59D7": "Shan "
+    "\u59DA": "Yao "
+    "\u59DC": "jiang "
+    "\u59DD": "shu "
+    "\u59E5": "lao "
+    "\u59E8": "yi "
+    "\u59EC": "ji "
+    "\u59FB": "yin "
+    "\u59FF": "zi "
+    "\u5A01": "wei "
+    "\u5A03": "wa "
+    "\u5A04": "Lou, Rui "
+    "\u5A07": "jiao "
+    "\u5A18": "niang "
+    "\u5A1B": "yu "
+    "\u5A1C": "nuo "
+    "\u5A1F": "juan "
+    "\u5A23": "di "
+    "\u5A25": "e "
+    "\u5A31": "yu "
+    "\u5A32": "wa "
+    "\u5A34": "xian "
+    "\u5A36": "qu "
+    "\u5A38": "qi "
+    "\u5A41": "lou rui "
+    "\u5A46": "po "
+    "\u5A49": "wan "
+    "\u5A55": "jie "
+    "\u5A5A": "hun "
+    "\u5A66": "fu "
+    "\u5A74": "ying "
+    "\u5A75": "chan "
+    "\u5A77": "ting "
+    "\u5A7A": "wu "
+    "\u5A92": "mei "
+    "\u5A9A": "mei "
+    "\u5A9B": "yuan "
+    "\u5AB3": "xi "
+    "\u5ABD": "ma "
+    "\u5AC1": "jia "
+    "\u5AC2": "sao "
+    "\u5ACC": "xian "
+    "\u5AE3": "yan "
+    "\u5AE6": "chang "
+    "\u5AE9": "nen "
+    "\u5AFB": "xian "
+    "\u5B09": "xi "
+    "\u5B0C": "jiao "
+    "\u5B30": "ying "
+    "\u5B34": "Ying "
+    "\u5B3E": "Lan "
+    "\u5B3F": "Yan "
+    "\u5B50": "zi "
+    "\u5B51": "jie "
+    "\u5B54": "kong "
+    "\u5B57": "zi "
+    "\u5B58": "cun "
+    "\u5B59": "sun "
+    "\u5B5A": "fu "
+    "\u5B5C": "zi "
+    "\u5B5D": "xiao "
+    "\u5B5F": "meng "
+    "\u5B63": "ji "
+    "\u5B64": "gu "
+    "\u5B66": "xue "
+    "\u5B69": "hai "
+    "\u5B6B": "sun "
+    "\u5B78": "xue "
+    "\u5B81": "ning "
+    "\u5B83": "ta "
+    "\u5B85": "zhai "
+    "\u5B87": "yu "
+    "\u5B88": "shou "
+    "\u5B89": "an "
+    "\u5B8B": "Song "
+    "\u5B8C": "wan "
+    "\u5B8F": "hong "
+    "\u5B97": "zong "
+    "\u5B98": "guan "
+    "\u5B99": "zhou "
+    "\u5B9A": "ding "
+    "\u5B9B": "wan "
+    "\u5B9C": "yi "
+    "\u5B9D": "bao "
+    "\u5B9E": "shi "
+    "\u5BA1": "shen "
+    "\u5BA2": "ke "
+    "\u5BA3": "xuan "
+    "\u5BA4": "shi "
+    "\u5BA6": "chcn "
+    "\u5BAA": "xian "
+    "\u5BAB": "gong "
+    "\u5BAE": "gong "
+    "\u5BB0": "zai "
+    "\u5BB3": "hai "
+    "\u5BB4": "yan "
+    "\u5BB5": "xiao "
+    "\u5BB6": "jia "
+    "\u5BB8": "chen "
+    "\u5BB9": "rong "
+    "\u5BBD": "kuan "
+    "\u5BBE": "bin "
+    "\u5BBF": "su "
+    "\u5BC2": "ji "
+    "\u5BC3": "yuan "
+    "\u5BC4": "ji "
+    "\u5BC5": "yin "
+    "\u5BC6": "mi "
+    "\u5BC7": "kou "
+    "\u5BCC": "fu "
+    "\u5BD2": "han "
+    "\u5BD3": "yu "
+    "\u5BD7": "Ning "
+    "\u5BDE": "mo "
+    "\u5BDF": "cha "
+    "\u5BE1": "gua "
+    "\u5BE6": "shi "
+    "\u5BE7": "ning "
+    "\u5BE8": "zhai "
+    "\u5BE9": "shen "
+    "\u5BEB": "xie "
+    "\u5BEC": "kuan "
+    "\u5BEF": "Jun "
+    "\u5BF0": "huan "
+    "\u5BF3": "bao "
+    "\u5BF6": "bao "
+    "\u5BF8": "cun "
+    "\u5BF9": "dui "
+    "\u5BFA": "si "
+    "\u5BFB": "xun "
+    "\u5BFC": "dao "
+    "\u5BFF": "shou "
+    "\u5C01": "feng "
+    "\u5C04": "she "
+    "\u5C06": "jiang "
+    "\u5C07": "jiang "
+    "\u5C08": "zhuan "
+    "\u5C09": "Wei "
+    "\u5C0A": "zun "
+    "\u5C0B": "xun "
+    "\u5C0D": "dui "
+    "\u5C0E": "dao "
+    "\u5C0F": "xiao "
+    "\u5C11": "shao "
+    "\u5C14": "er "
+    "\u5C15": "ga "
+    "\u5C16": "jian "
+    "\u5C18": "chen "
+    "\u5C1A": "shang "
+    "\u5C1D": "chang "
+    "\u5C21": "kun "
+    "\u5C24": "you "
+    "\u5C27": "yao "
+    "\u5C31": "jiu "
+    "\u5C38": "shi "
+    "\u5C39": "yin "
+    "\u5C3A": "chi "
+    "\u5C3C": "ni "
+    "\u5C3D": "jin "
+    "\u5C3E": "wei "
+    "\u5C3F": "niao "
+    "\u5C40": "ju "
+    "\u5C41": "pi "
+    "\u5C42": "ceng "
+    "\u5C45": "ju "
+    "\u5C46": "jie "
+    "\u5C48": "qu "
+    "\u5C4A": "jie "
+    "\u5C4B": "wu "
+    "\u5C4F": "ping "
+    "\u5C55": "zhan "
+    "\u5C5B": "Ping "
+    "\u5C5E": "shu "
+    "\u5C60": "tu "
+    "\u5C64": "ceng "
+    "\u5C65": "lu "
+    "\u5C6C": "shu "
+    "\u5C6F": "tun "
+    "\u5C71": "shan "
+    "\u5C79": "yi "
+    "\u5C7A": "Qi "
+    "\u5C7F": "yu "
+    "\u5C81": "sui "
+    "\u5C82": "qi "
+    "\u5C91": "Cen "
+    "\u5C97": "gang "
+    "\u5C9B": "dao "
+    "\u5CA1": "gang "
+    "\u5CA9": "yan "
+    "\u5CAD": "ling "
+    "\u5CB1": "dai "
+    "\u5CB3": "yue "
+    "\u5CB8": "an "
+    "\u5CD2": "tong "
+    "\u5CD9": "shi "
+    "\u5CE1": "xia "
+    "\u5CE8": "E "
+    "\u5CED": "Qiao "
+    "\u5CEF": "feng "
+    "\u5CF0": "feng "
+    "\u5CF6": "dao "
+    "\u5CFB": "jun "
+    "\u5CFD": "xia "
+    "\u5D06": "kong "
+    "\u5D07": "chong "
+    "\u5D0D": "lai "
+    "\u5D0E": "qi "
+    "\u5D10": "kun "
+    "\u5D11": "Kun "
+    "\u5D14": "cui "
+    "\u5D16": "ya "
+    "\u5D17": "Gang "
+    "\u5D1B": "jue "
+    "\u5D1E": "Guo "
+    "\u5D22": "zheng "
+    "\u5D27": "song "
+    "\u5D34": "wei "
+    "\u5D47": "ji "
+    "\u5D4C": "qian "
+    "\u5D50": "lan "
+    "\u5D57": "sui "
+    "\u5D58": "rong "
+    "\u5D69": "song "
+    "\u5D6C": "wei "
+    "\u5D82": "zhang "
+    "\u5DA0": "qiao "
+    "\u5DA7": "yi "
+    "\u5DBA": "ling "
+    "\u5DBC": "yu "
+    "\u5DBD": "yue "
+    "\u5DC5": "Dian "
+    "\u5DCC": "yan "
+    "\u5DCD": "Wei "
+    "\u5DD6": "yan "
+    "\u5DD7": "yan "
+    "\u5DDD": "chuan "
+    "\u5DDE": "zhou "
+    "\u5DE1": "xun "
+    "\u5DE2": "chao "
+    "\u5DE5": "gong "
+    "\u5DE6": "zuo "
+    "\u5DE7": "qiao "
+    "\u5DE8": "ju "
+    "\u5DE9": "gong "
+    "\u5DEB": "wu "
+    "\u5DEE": "cha "
+    "\u5DF1": "ji "
+    "\u5DF2": "yi "
+    "\u5DF4": "ba "
+    "\u5DF7": "xiang "
+    "\u5DFD": "Xun "
+    "\u5DFE": "jin "
+    "\u5E01": "bi "
+    "\u5E02": "shi "
+    "\u5E03": "bu "
+    "\u5E05": "shuai "
+    "\u5E06": "Fan "
+    "\u5E08": "shi "
+    "\u5E0C": "xi "
+    "\u5E10": "zhang "
+    "\u5E15": "pa "
+    "\u5E16": "tie "
+    "\u5E18": "lian "
+    "\u5E1B": "bo "
+    "\u5E1C": "zhi "
+    "\u5E1D": "di "
+    "\u5E25": "shuai "
+    "\u5E26": "dai "
+    "\u5E2B": "shi "
+    "\u5E2D": "xi "
+    "\u5E2E": "bang "
+    "\u5E36": "dai "
+    "\u5E38": "chang "
+    "\u5E3D": "mao "
+    "\u5E45": "fu "
+    "\u5E55": "mu "
+    "\u5E63": "bi "
+    "\u5E6B": "bang "
+    "\u5E72": "gan "
+    "\u5E73": "ping "
+    "\u5E74": "nian "
+    "\u5E76": "bing "
+    "\u5E78": "xing "
+    "\u5E79": "gan "
+    "\u5E7B": "huan "
+    "\u5E7C": "you "
+    "\u5E7D": "you "
+    "\u5E7E": "ji "
+    "\u5E7F": "guang "
+    "\u5E84": "zhuang "
+    "\u5E86": "qing "
+    "\u5E8A": "chuang "
+    "\u5E8B": "gui "
+    "\u5E8F": "xu "
+    "\u5E90": "lu "
+    "\u5E93": "ku "
+    "\u5E94": "ying "
+    "\u5E95": "di "
+    "\u5E97": "dian "
+    "\u5E99": "miao "
+    "\u5E9A": "geng "
+    "\u5E9C": "fu "
+    "\u5E9E": "pang "
+    "\u5E9F": "fei "
+    "\u5EA0": "xiang "
+    "\u5EA6": "du "
+    "\u5EA7": "zuo "
+    "\u5EAB": "ku "
+    "\u5EAD": "ting "
+    "\u5EB5": "an "
+    "\u5EB7": "kang "
+    "\u5EB8": "yong "
+    "\u5EC8": "xia "
+    "\u5EC9": "lian "
+    "\u5ECA": "lang "
+    "\u5ED6": "liao "
+    "\u5EDF": "miao "
+    "\u5EE0": "chang "
+    "\u5EE2": "fei "
+    "\u5EE3": "guang "
+    "\u5EEC": "lu "
+    "\u5EF0": "ting "
+    "\u5EF3": "ting "
+    "\u5EF6": "yan "
+    "\u5EF7": "ting "
+    "\u5EFA": "jian "
+    "\u5EFF": "nian "
+    "\u5F00": "kai "
+    "\u5F02": "yi "
+    "\u5F03": "qi "
+    "\u5F04": "nong "
+    "\u5F08": "yi "
+    "\u5F0F": "shi "
+    "\u5F13": "Gong "
+    "\u5F15": "yin "
+    "\u5F17": "fu "
+    "\u5F18": "Hong "
+    "\u5F1B": "chi "
+    "\u5F1F": "di "
+    "\u5F20": "zhang "
+    "\u5F25": "mi "
+    "\u5F26": "xian "
+    "\u5F2F": "wan "
+    "\u5F31": "ruo "
+    "\u5F35": "zhang "
+    "\u5F37": "qiang "
+    "\u5F39": "dan "
+    "\u5F3A": "qiang "
+    "\u5F3C": "bi "
+    "\u5F48": "dan "
+    "\u5F4C": "mi "
+    "\u5F4E": "wan "
+    "\u5F52": "gui "
+    "\u5F53": "dang "
+    "\u5F55": "lu "
+    "\u5F59": "hui "
+    "\u5F5A": "hui "
+    "\u5F5C": "yi "
+    "\u5F5D": "Yi "
+    "\u5F62": "xing "
+    "\u5F64": "tong "
+    "\u5F65": "yan "
+    "\u5F66": "yan "
+    "\u5F67": "yu "
+    "\u5F69": "cai "
+    "\u5F6A": "biao "
+    "\u5F6B": "diao "
+    "\u5F6C": "bin "
+    "\u5F6D": "Peng "
+    "\u5F70": "zhang "
+    "\u5F71": "ying "
+    "\u5F79": "yi "
+    "\u5F7B": "che "
+    "\u5F7C": "bi "
+    "\u5F80": "wang "
+    "\u5F81": "zheng "
+    "\u5F84": "jing "
+    "\u5F85": "dai "
+    "\u5F88": "hen "
+    "\u5F89": "yang "
+    "\u5F8A": "huai "
+    "\u5F8B": "lu "
+    "\u5F8C": "hou "
+    "\u5F90": "xu "
+    "\u5F91": "jing "
+    "\u5F92": "tu "
+    "\u5F97": "de "
+    "\u5F98": "Pai "
+    "\u5F9C": "Chang "
+    "\u5F9E": "cong "
+    "\u5FA1": "yu "
+    "\u5FA9": "fu "
+    "\u5FAA": "xun "
+    "\u5FAE": "wei "
+    "\u5FB4": "Zheng "
+    "\u5FB5": "zheng "
+    "\u5FB7": "de "
+    "\u5FB9": "che "
+    "\u5FBD": "hui "
+    "\u5FC3": "xin "
+    "\u5FC5": "bi "
+    "\u5FC6": "yi "
+    "\u5FCC": "ji "
+    "\u5FCD": "ren "
+    "\u5FD7": "zhi "
+    "\u5FD8": "wang "
+    "\u5FD9": "mang "
+    "\u5FE0": "zhong "
+    "\u5FE7": "you "
+    "\u5FEB": "kuai "
+    "\u5FF5": "nian "
+    "\u5FFB": "Xin "
+    "\u5FFD": "hu "
+    "\u6000": "huai "
+    "\u6001": "tai "
+    "\u600E": "zen "
+    "\u6012": "nu "
+    "\u6014": "zheng "
+    "\u6015": "pa "
+    "\u6016": "bu "
+    "\u601C": "lian "
+    "\u601D": "si "
+    "\u6021": "yi "
+    "\u6025": "ji "
+    "\u6027": "xing "
+    "\u6028": "yuan "
+    "\u602A": "guai "
+    "\u603B": "zong "
+    "\u6042": "xun "
+    "\u6046": "heng "
+    "\u604B": "lian "
+    "\u6050": "kong "
+    "\u6052": "heng "
+    "\u6055": "shu "
+    "\u6062": "hui "
+    "\u6068": "hen "
+    "\u6069": "en "
+    "\u606A": "ke "
+    "\u606D": "gong "
+    "\u606F": "xi "
+    "\u6070": "qia "
+    "\u6076": "e "
+    "\u607A": "kai "
+    "\u607C": "nao "
+    "\u607D": "Yun "
+    "\u6084": "qiao "
+    "\u6089": "xi "
+    "\u608C": "ti "
+    "\u6094": "hui "
+    "\u609A": "Song "
+    "\u609F": "wu "
+    "\u60A0": "you "
+    "\u60A3": "huan "
+    "\u60A6": "yue "
+    "\u60A8": "nin "
+    "\u60AC": "xuan "
+    "\u60B2": "bei "
+    "\u60BC": "dao "
+    "\u60C5": "qing "
+    "\u60CA": "jing "
+    "\u60D1": "huo "
+    "\u60D5": "ti "
+    "\u60DC": "xi "
+    "\u60DF": "wei "
+    "\u60E0": "hui "
+    "\u60E1": "e "
+    "\u60E7": "ju "
+    "\u60E8": "can "
+    "\u60E9": "cheng "
+    "\u60EA": "de "
+    "\u60EC": "Qie "
+    "\u60EF": "guan "
+    "\u60F1": "nao "
+    "\u60F3": "xiang "
+    "\u60F6": "huang "
+    "\u60F9": "re "
+    "\u60FA": "Huang "
+    "\u6101": "chou "
+    "\u6108": "yu "
+    "\u6109": "yu "
+    "\u610F": "yi "
+    "\u611A": "yu "
+    "\u611B": "ai "
+    "\u611F": "gan "
+    "\u6124": "fen "
+    "\u6127": "kui "
+    "\u612B": "su "
+    "\u6137": "kai "
+    "\u613C": "Shen "
+    "\u613F": "yuan "
+    "\u6148": "ci "
+    "\u614B": "tai "
+    "\u614C": "huang "
+    "\u614E": "shen "
+    "\u6155": "mu "
+    "\u6158": "can "
+    "\u6162": "man "
+    "\u6167": "hui "
+    "\u6168": "kai "
+    "\u616E": "lu "
+    "\u6170": "wei "
+    "\u6175": "Yong "
+    "\u6176": "qing "
+    "\u6177": "Kang "
+    "\u617E": "yu "
+    "\u6182": "you "
+    "\u61B2": "xian "
+    "\u61B6": "yi "
+    "\u61BE": "han "
+    "\u61C2": "dong "
+    "\u61C7": "ken "
+    "\u61C9": "ying "
+    "\u61CB": "mao "
+    "\u61D0": "Huai "
+    "\u61D2": "lan "
+    "\u61F2": "cheng "
+    "\u61F6": "lan "
+    "\u61F7": "huai "
+    "\u61F8": "xuan "
+    "\u61FA": "chan "
+    "\u61FF": "yi "
+    "\u6200": "lian "
+    "\u6208": "ge "
+    "\u620A": "wu "
+    "\u620C": "xu "
+    "\u620E": "rong "
+    "\u620F": "xi "
+    "\u6210": "cheng "
+    "\u6211": "wo "
+    "\u6212": "jie "
+    "\u6216": "huo "
+    "\u6218": "zhan "
+    "\u621A": "qi "
+    "\u621F": "Ji "
+    "\u6221": "kan "
+    "\u6226": "zhan "
+    "\u622A": "jie "
+    "\u622C": "jian "
+    "\u622F": "xi "
+    "\u6230": "zhan "
+    "\u6232": "xi "
+    "\u6233": "chuo "
+    "\u6234": "dai "
+    "\u6236": "hu "
+    "\u6237": "hu "
+    "\u623F": "fang "
+    "\u6240": "suo "
+    "\u6241": "bian "
+    "\u6247": "shan "
+    "\u6248": "Hu "
+    "\u624B": "shou "
+    "\u624D": "cai "
+    "\u624E": "zha "
+    "\u6251": "pu "
+    "\u6253": "da "
+    "\u6254": "reng "
+    "\u6258": "tuo "
+    "\u6263": "kou "
+    "\u6267": "zhi "
+    "\u6269": "kuo "
+    "\u626B": "sao "
+    "\u626C": "yang "
+    "\u626D": "niu "
+    "\u626E": "ban "
+    "\u626F": "che "
+    "\u6270": "rao "
+    "\u6276": "fu "
+    "\u6279": "pi "
+    "\u627E": "zhao "
+    "\u627F": "cheng "
+    "\u6280": "ji "
+    "\u6284": "chao "
+    "\u6289": "jue "
+    "\u628A": "ba "
+    "\u6291": "yi "
+    "\u6292": "shu "
+    "\u6293": "zhua "
+    "\u6295": "tou "
+    "\u6296": "dou "
+    "\u6297": "kang "
+    "\u6298": "zhe "
+    "\u629A": "fu "
+    "\u629B": "pao "
+    "\u62A2": "qiang "
+    "\u62A4": "hu "
+    "\u62A5": "bao "
+    "\u62AB": "pi "
+    "\u62AC": "tai "
+    "\u62B1": "bao "
+    "\u62B5": "di "
+    "\u62B9": "ma "
+    "\u62BC": "ya "
+    "\u62BD": "chou "
+    "\u62C2": "fu "
+    "\u62C5": "dan "
+    "\u62C6": "chai "
+    "\u62C9": "la "
+    "\u62CD": "pai "
+    "\u62D0": "guai "
+    "\u62D2": "ju "
+    "\u62D3": "ta "
+    "\u62D4": "ba "
+    "\u62D6": "tuo "
+    "\u62D8": "ju "
+    "\u62D9": "Zhuo "
+    "\u62DA": "pin "
+    "\u62DB": "zhao "
+    "\u62DC": "bai "
+    "\u62DF": "ni "
+    "\u62E5": "yong "
+    "\u62E6": "lan "
+    "\u62E8": "bo "
+    "\u62E9": "ze "
+    "\u62EC": "kuo "
+    "\u62EF": "zheng "
+    "\u62F1": "gong "
+    "\u62F3": "quan "
+    "\u62F4": "shuan "
+    "\u62FC": "pin "
+    "\u62FE": "shi "
+    "\u62FF": "na "
+    "\u6301": "chi "
+    "\u6302": "gua "
+    "\u6307": "zhi "
+    "\u6309": "an "
+    "\u6311": "tiao "
+    "\u6316": "wa "
+    "\u631A": "Zhi "
+    "\u6321": "dang "
+    "\u6323": "zheng "
+    "\u6324": "ji "
+    "\u6325": "hui "
+    "\u6328": "ai "
+    "\u632B": "cuo "
+    "\u632F": "zhen "
+    "\u633A": "ting "
+    "\u633D": "wan "
+    "\u6349": "zhuo "
+    "\u634C": "ba "
+    "\u634F": "nie "
+    "\u6350": "juan "
+    "\u6355": "bu "
+    "\u635C": "sou "
+    "\u635E": "lao "
+    "\u635F": "sun "
+    "\u6362": "huan "
+    "\u6367": "peng "
+    "\u636E": "ju "
+    "\u6377": "jie "
+    "\u637B": "Nian "
+    "\u6380": "xian "
+    "\u6383": "sao "
+    "\u6387": "duo "
+    "\u6388": "shou "
+    "\u6389": "diao "
+    "\u638C": "zhang "
+    "\u638F": "tao "
+    "\u6390": "qia "
+    "\u6392": "pai "
+    "\u6399": "zheng "
+    "\u63A0": "lue "
+    "\u63A1": "cai "
+    "\u63A2": "tan "
+    "\u63A5": "jie "
+    "\u63A7": "kong "
+    "\u63A8": "tui "
+    "\u63A9": "yan "
+    "\u63AA": "cuo "
+    "\u63B7": "zhi "
+    "\u63CF": "miao "
+    "\u63D0": "ti "
+    "\u63D2": "cha "
+    "\u63D6": "yi "
+    "\u63DA": "yang "
+    "\u63E1": "wo "
+    "\u63ED": "jie "
+    "\u63EE": "Hui "
+    "\u63F4": "yuan "
+    "\u6401": "ge "
+    "\u6405": "jiao "
+    "\u640D": "sun "
+    "\u6416": "yao "
+    "\u641C": "sou "
+    "\u641E": "gao "
+    "\u642C": "ban "
+    "\u642D": "da "
+    "\u643A": "xie "
+    "\u6444": "she "
+    "\u6446": "bai "
+    "\u6447": "yao "
+    "\u644A": "tan "
+    "\u6454": "shuai "
+    "\u6458": "zhai "
+    "\u6467": "cui "
+    "\u6469": "mo "
+    "\u646D": "zhi "
+    "\u6476": "Tuan "
+    "\u6478": "mo "
+    "\u647A": "zhe "
+    "\u6484": "ying "
+    "\u6487": "pie "
+    "\u6491": "cheng "
+    "\u6492": "sa "
+    "\u6495": "si "
+    "\u649E": "zhuang "
+    "\u64A4": "che "
+    "\u64A5": "bo "
+    "\u64AB": "Fu "
+    "\u64AD": "bo "
+    "\u64AE": "cuo "
+    "\u64B0": "zhuan "
+    "\u64B7": "xie "
+    "\u64C4": "lu "
+    "\u64C7": "ze "
+    "\u64CD": "cao "
+    "\u64CE": "qing "
+    "\u64D2": "qin "
+    "\u64D4": "dan "
+    "\u64DA": "ju "
+    "\u64E6": "ca "
+    "\u64F4": "kuo "
+    "\u64F7": "xie "
+    "\u64FE": "rao "
+    "\u6500": "pan "
+    "\u651D": "she "
+    "\u652C": "lan "
+    "\u652F": "zhi "
+    "\u6536": "shou "
+    "\u6537": "kao "
+    "\u6538": "you "
+    "\u6539": "gai "
+    "\u653B": "gong "
+    "\u653E": "fang "
+    "\u653F": "zheng "
+    "\u6545": "gu "
+    "\u6548": "xiao "
+    "\u654C": "di "
+    "\u654D": "xu "
+    "\u654E": "jiao "
+    "\u654F": "min "
+    "\u6551": "jiu "
+    "\u6555": "chi "
+    "\u6556": "ao "
+    "\u6558": "xu "
+    "\u6559": "jiao "
+    "\u655E": "chang "
+    "\u6562": "gan "
+    "\u6563": "san "
+    "\u6566": "dun "
+    "\u656C": "jing "
+    "\u6570": "shu "
+    "\u6572": "qiao "
+    "\u6574": "zheng "
+    "\u6578": "shu "
+    "\u6587": "wen "
+    "\u658B": "zhai "
+    "\u658C": "bin "
+    "\u6590": "fei "
+    "\u6591": "ban "
+    "\u6597": "dou "
+    "\u6599": "liao "
+    "\u659C": "xie "
+    "\u65A1": "wo "
+    "\u65A4": "jin "
+    "\u65A5": "chi "
+    "\u65A9": "zhan "
+    "\u65AD": "duan "
+    "\u65AF": "si "
+    "\u65B0": "xin "
+    "\u65B7": "duan "
+    "\u65B9": "fang "
+    "\u65BC": "Yu "
+    "\u65BD": "shi "
+    "\u65C1": "pang "
+    "\u65C5": "lu "
+    "\u65CB": "xuan "
+    "\u65CC": "Jing "
+    "\u65CF": "zu "
+    "\u65D6": "yi "
+    "\u65D7": "qi "
+    "\u65E0": "wu "
+    "\u65E2": "ji "
+    "\u65E5": "ri "
+    "\u65E6": "dan "
+    "\u65E7": "jiu "
+    "\u65E8": "zhi "
+    "\u65E9": "zao "
+    "\u65EC": "xun "
+    "\u65ED": "Xu "
+    "\u65F1": "han "
+    "\u65F6": "shi "
+    "\u65F7": "kuang "
+    "\u65FA": "wang "
+    "\u65FB": "Min "
+    "\u6600": "yun "
+    "\u6602": "ang "
+    "\u6606": "kun "
+    "\u6607": "Sheng "
+    "\u6609": "fang "
+    "\u660A": "hao "
+    "\u660C": "chang "
+    "\u660E": "ming "
+    "\u660F": "hun "
+    "\u6613": "yi "
+    "\u6614": "xi "
+    "\u6615": "Xin "
+    "\u661F": "xing "
+    "\u6620": "ying "
+    "\u6625": "chun "
+    "\u6627": "mei "
+    "\u6628": "zuo "
+    "\u662D": "chao "
+    "\u662F": "shi "
+    "\u6631": "yu "
+    "\u6636": "Chang "
+    "\u663E": "xian "
+    "\u6641": "Chao "
+    "\u6642": "shi "
+    "\u6643": "huang "
+    "\u6649": "jin "
+    "\u664B": "jin "
+    "\u664F": "Yan "
+    "\u6652": "shai "
+    "\u6653": "xiao "
+    "\u6654": "ye "
+    "\u6655": "yun "
+    "\u6656": "hui "
+    "\u6657": "Han "
+    "\u665A": "wan "
+    "\u665D": "hua "
+    "\u665F": "sheng "
+    "\u6664": "wu "
+    "\u6668": "chen "
+    "\u666E": "pu "
+    "\u666F": "jing "
+    "\u6670": "xi "
+    "\u6674": "qing "
+    "\u6676": "jing "
+    "\u667A": "zhi "
+    "\u6682": "zan "
+    "\u6684": "xuan "
+    "\u6689": "hui "
+    "\u6696": "nuan "
+    "\u6697": "an "
+    "\u6698": "Yang "
+    "\u66A2": "chang "
+    "\u66A8": "ji "
+    "\u66AB": "zan "
+    "\u66AE": "mu "
+    "\u66B4": "bao "
+    "\u66C1": "ji "
+    "\u66C4": "Ye "
+    "\u66C6": "li "
+    "\u66C7": "tan "
+    "\u66C9": "xiao "
+    "\u66D9": "shu "
+    "\u66DC": "yao "
+    "\u66DD": "Bao "
+    "\u66E0": "kuang "
+    "\u66E1": "die "
+    "\u66E6": "Xi "
+    "\u66F0": "yue "
+    "\u66F2": "qu "
+    "\u66F3": "ye "
+    "\u66F4": "geng "
+    "\u66F8": "shu "
+    "\u66F9": "Cao "
+    "\u66FC": "man "
+    "\u66FD": "Zeng "
+    "\u66FE": "ceng "
+    "\u66FF": "ti "
+    "\u6700": "zui "
+    "\u6703": "hui "
+    "\u6708": "yue "
+    "\u6709": "you "
+    "\u670B": "peng "
+    "\u670D": "fu "
+    "\u6710": "gou "
+    "\u6714": "shuo "
+    "\u6717": "lang "
+    "\u671B": "wang "
+    "\u671D": "chao "
+    "\u671F": "qi "
+    "\u6725": "lao "
+    "\u6726": "meng "
+    "\u6728": "mu "
+    "\u672A": "wei "
+    "\u672B": "mo "
+    "\u672C": "ben "
+    "\u672D": "zha "
+    "\u672E": "shu "
+    "\u672F": "shu "
+    "\u6731": "zhu "
+    "\u6734": "pu "
+    "\u6735": "duo "
+    "\u673A": "ji "
+    "\u673D": "xiu "
+    "\u6740": "sha "
+    "\u6742": "za "
+    "\u6743": "quan "
+    "\u6746": "gan "
+    "\u6749": "sha "
+    "\u674E": "li "
+    "\u674F": "Xing "
+    "\u6750": "cai "
+    "\u6751": "cun "
+    "\u6756": "zhang "
+    "\u675C": "du "
+    "\u675E": "qi "
+    "\u675F": "shu "
+    "\u6761": "tiao "
+    "\u6765": "lai "
+    "\u6768": "yang "
+    "\u676D": "Hang "
+    "\u676F": "bei "
+    "\u6770": "jie "
+    "\u6771": "dong "
+    "\u677E": "song "
+    "\u677F": "ban "
+    "\u6781": "ji "
+    "\u6784": "gou "
+    "\u678F": "nan "
+    "\u6790": "xi "
+    "\u6795": "zhen "
+    "\u6797": "lin "
+    "\u6798": "rui "
+    "\u679A": "mei "
+    "\u679C": "guo "
+    "\u679D": "zhi "
+    "\u67A2": "shu "
+    "\u67A3": "zao "
+    "\u67AA": "qiang "
+    "\u67AB": "feng "
+    "\u67AD": "xiao "
+    "\u67AF": "ku "
+    "\u67B0": "ping "
+    "\u67B6": "jia "
+    "\u67C4": "bing "
+    "\u67CF": "bai "
+    "\u67D0": "mou "
+    "\u67D2": "qi "
+    "\u67D3": "ran "
+    "\u67D4": "rou "
+    "\u67DC": "gui "
+    "\u67E5": "cha "
+    "\u67EF": "ke "
+    "\u67F1": "zhu "
+    "\u67F3": "liu "
+    "\u67F4": "chai "
+    "\u6807": "biao "
+    "\u680B": "dong "
+    "\u680F": "lan "
+    "\u6811": "shu "
+    "\u6816": "Qi "
+    "\u6817": "li "
+    "\u6821": "xiao "
+    "\u682A": "zhu "
+    "\u6837": "yang "
+    "\u6838": "he "
+    "\u6839": "gen "
+    "\u683C": "ge "
+    "\u683E": "luan "
+    "\u6842": "gui "
+    "\u6843": "tao "
+    "\u6846": "kuang "
+    "\u6848": "an "
+    "\u684C": "zhuo "
+    "\u6850": "tong "
+    "\u6851": "sang "
+    "\u6853": "huan "
+    "\u6862": "zhen "
+    "\u6863": "dang "
+    "\u6865": "qiao "
+    "\u6866": "hua "
+    "\u6867": "Hui "
+    "\u6876": "tong "
+    "\u6881": "liang "
+    "\u6885": "mei "
+    "\u6893": "zi "
+    "\u689D": "tiao "
+    "\u68A6": "meng "
+    "\u68A7": "wu "
+    "\u68A8": "li "
+    "\u68AF": "ti "
+    "\u68B0": "xie "
+    "\u68B5": "fan "
+    "\u68C0": "jian "
+    "\u68C4": "qi "
+    "\u68C9": "mian "
+    "\u68CB": "qi "
+    "\u68CD": "gun "
+    "\u68D2": "bang "
+    "\u68D7": "zao "
+    "\u68DA": "peng "
+    "\u68DF": "dong "
+    "\u68E0": "tang "
+    "\u68E1": "gang "
+    "\u68E3": "di "
+    "\u68E8": "qi "
+    "\u68EA": "Yan "
+    "\u68EB": "yu "
+    "\u68EE": "sen "
+    "\u68F2": "qi "
+    "\u68F5": "ke "
+    "\u68FB": "fen "
+    "\u6905": "yi "
+    "\u690D": "zhi "
+    "\u6912": "jiao "
+    "\u693F": "chun "
+    "\u694A": "Yang "
+    "\u6953": "Feng "
+    "\u6959": "mao "
+    "\u695A": "chu "
+    "\u6960": "nan "
+    "\u6968": "zhen "
+    "\u696B": "ji "
+    "\u696D": "ye "
+    "\u6975": "ji "
+    "\u6977": "kai "
+    "\u6979": "ying "
+    "\u697C": "lou "
+    "\u6982": "gai "
+    "\u6984": "lan "
+    "\u6986": "yu "
+    "\u6989": "Ju "
+    "\u6995": "rong "
+    "\u6996": "Gu "
+    "\u699C": "bang "
+    "\u69AE": "rong "
+    "\u69B4": "liu "
+    "\u69C3": "pan "
+    "\u69CB": "gou "
+    "\u69D0": "Huai "
+    "\u69D8": "yang "
+    "\u69E9": "gai "
+    "\u69EA": "gai "
+    "\u6A01": "chun "
+    "\u6A02": "yue "
+    "\u6A05": "zong "
+    "\u6A0A": "fan "
+    "\u6A11": "liang "
+    "\u6A13": "lou "
+    "\u6A19": "biao "
+    "\u6A1E": "shu "
+    "\u6A21": "mo "
+    "\u6A23": "yang "
+    "\u6A2A": "heng "
+    "\u6A35": "qiao "
+    "\u6A38": "pu "
+    "\u6A39": "shu "
+    "\u6A3A": "hua "
+    "\u6A3E": "yue "
+    "\u6A4B": "qiao "
+    "\u6A5F": "ji "
+    "\u6A61": "xiang "
+    "\u6A6B": "heng "
+    "\u6A80": "tan "
+    "\u6A89": "cheng "
+    "\u6A94": "dang "
+    "\u6AA2": "jian "
+    "\u6AAC": "meng "
+    "\u6AB8": "ning "
+    "\u6AC3": "gui "
+    "\u6AC6": "kui "
+    "\u6AC8": "deng "
+    "\u6ADF": "Li "
+    "\u6AFB": "ying "
+    "\u6B04": "lan "
+    "\u6B0A": "quan "
+    "\u6B20": "qian "
+    "\u6B21": "ci "
+    "\u6B22": "huan "
+    "\u6B23": "xin "
+    "\u6B27": "ou "
+    "\u6B32": "yu "
+    "\u6B3A": "qi "
+    "\u6B3D": "qin "
+    "\u6B3E": "kuan "
+    "\u6B46": "xin "
+    "\u6B47": "xie "
+    "\u6B49": "qian "
+    "\u6B4C": "ge "
+    "\u6B50": "Ou "
+    "\u6B61": "huan "
+    "\u6B62": "zhi "
+    "\u6B63": "zheng "
+    "\u6B64": "ci "
+    "\u6B65": "bu "
+    "\u6B66": "wu "
+    "\u6B67": "qi "
+    "\u6B6A": "wai "
+    "\u6B72": "sui "
+    "\u6B74": "li "
+    "\u6B77": "li "
+    "\u6B78": "gui "
+    "\u6B7B": "si "
+    "\u6B7C": "jian "
+    "\u6B89": "xun "
+    "\u6B8A": "shu "
+    "\u6B8B": "can "
+    "\u6B96": "zhi "
+    "\u6B98": "can "
+    "\u6BAF": "bin "
+    "\u6BB5": "duan "
+    "\u6BB7": "yin "
+    "\u6BBF": "dian "
+    "\u6BC1": "hui "
+    "\u6BC5": "yi "
+    "\u6BCD": "mu "
+    "\u6BCF": "mei "
+    "\u6BD2": "du "
+    "\u6BD3": "yu "
+    "\u6BD4": "bi "
+    "\u6BD5": "bi "
+    "\u6BD8": "Pi "
+    "\u6BDB": "mao "
+    "\u6BE1": "zhan "
+    "\u6BEB": "hao "
+    "\u6BEF": "tan "
+    "\u6C0F": "shi "
+    "\u6C11": "min "
+    "\u6C13": "mang "
+    "\u6C14": "qi "
+    "\u6C1B": "fen "
+    "\u6C23": "qi "
+    "\u6C34": "shui "
+    "\u6C38": "yong "
+    "\u6C40": "ting "
+    "\u6C42": "qiu "
+    "\u6C47": "hui "
+    "\u6C49": "han "
+    "\u6C55": "Shan "
+    "\u6C57": "han "
+    "\u6C5B": "xun "
+    "\u6C5D": "ro "
+    "\u6C5F": "jiang "
+    "\u6C60": "chi "
+    "\u6C61": "wu "
+    "\u6C64": "tang "
+    "\u6C68": "mi "
+    "\u6C6A": "wang "
+    "\u6C72": "ji "
+    "\u6C76": "Wen "
+    "\u6C7A": "jue "
+    "\u6C7D": "qi "
+    "\u6C81": "qin "
+    "\u6C82": "yi "
+    "\u6C83": "Wo "
+    "\u6C85": "yuan "
+    "\u6C88": "Shen "
+    "\u6C89": "chen "
+    "\u6C8C": "dun "
+    "\u6C90": "mu "
+    "\u6C99": "sha "
+    "\u6C9B": "pei "
+    "\u6C9F": "gou "
+    "\u6CA1": "mei "
+    "\u6CA7": "cang "
+    "\u6CAA": "hu "
+    "\u6CAB": "mo "
+    "\u6CB3": "he "
+    "\u6CB9": "you "
+    "\u6CBB": "zhi "
+    "\u6CBD": "gu "
+    "\u6CBE": "zhan "
+    "\u6CBF": "yan "
+    "\u6CC1": "kuang "
+    "\u6CC4": "xie "
+    "\u6CC9": "quan "
+    "\u6CCA": "bo "
+    "\u6CCC": "Bi "
+    "\u6CD3": "Hong "
+    "\u6CD5": "fa "
+    "\u6CD7": "si "
+    "\u6CDB": "fan "
+    "\u6CE0": "ling "
+    "\u6CE1": "pao "
+    "\u6CE2": "bo "
+    "\u6CE3": "qi "
+    "\u6CE5": "ni "
+    "\u6CE8": "zhu "
+    "\u6CEA": "lei "
+    "\u6CF0": "tai "
+    "\u6CF3": "yong "
+    "\u6CF8": "Lu "
+    "\u6CFC": "po "
+    "\u6CFD": "ze "
+    "\u6CFE": "jing "
+    "\u6D01": "jie "
+    "\u6D0B": "yang "
+    "\u6D12": "sa "
+    "\u6D17": "xi "
+    "\u6D1B": "Luo "
+    "\u6D1E": "dong "
+    "\u6D25": "jin "
+    "\u6D2A": "hong "
+    "\u6D31": "er "
+    "\u6D32": "zhou "
+    "\u6D35": "Xun "
+    "\u6D3B": "huo "
+    "\u6D3E": "pai "
+    "\u6D41": "liu "
+    "\u6D45": "qian "
+    "\u6D46": "jiang "
+    "\u6D48": "Zhen "
+    "\u6D4B": "ce "
+    "\u6D4E": "ji "
+    "\u6D51": "hun "
+    "\u6D52": "hu "
+    "\u6D53": "nong "
+    "\u6D59": "Zhe "
+    "\u6D5A": "jun "
+    "\u6D66": "pu "
+    "\u6D69": "hao "
+    "\u6D6A": "lang "
+    "\u6D6E": "fu "
+    "\u6D6F": "wu "
+    "\u6D74": "yu "
+    "\u6D77": "hai "
+    "\u6D78": "jin "
+    "\u6D82": "Tu Jie "
+    "\u6D85": "nie "
+    "\u6D87": "jing "
+    "\u6D88": "xiao "
+    "\u6D89": "she "
+    "\u6D8C": "yong "
+    "\u6D8E": "xian "
+    "\u6D91": "su "
+    "\u6D93": "juan "
+    "\u6D9B": "tao "
+    "\u6DA4": "di "
+    "\u6DA6": "run "
+    "\u6DA8": "zhang "
+    "\u6DAF": "ya "
+    "\u6DB2": "ye "
+    "\u6DB5": "han "
+    "\u6DBC": "liang "
+    "\u6DC0": "dian "
+    "\u6DC4": "Zi "
+    "\u6DC5": "Xi "
+    "\u6DC6": "xiao "
+    "\u6DCB": "lin "
+    "\u6DD1": "shu "
+    "\u6DD8": "tao "
+    "\u6DDA": "lei "
+    "\u6DDB": "zhe "
+    "\u6DDE": "song "
+    "\u6DE1": "dan "
+    "\u6DE8": " "
+    "\u6DE9": "ling "
+    "\u6DEA": "lun "
+    "\u6DEB": "yin "
+    "\u6DEC": "cui "
+    "\u6DEE": "huai "
+    "\u6DF1": "shen "
+    "\u6DF3": "Chun "
+    "\u6DF5": "yuan "
+    "\u6DF7": "hun "
+    "\u6DF8": "qing "
+    "\u6DFA": "qian "
+    "\u6DFB": "tian "
+    "\u6DFC": "miao "
+    "\u6E05": "qing "
+    "\u6E0A": "Yuan "
+    "\u6E10": "jian "
+    "\u6E14": "yu "
+    "\u6E1A": "zhu "
+    "\u6E1D": "yu "
+    "\u6E20": "qu "
+    "\u6E21": "du "
+    "\u6E24": "bo "
+    "\u6E26": "wo "
+    "\u6E29": "wen "
+    "\u6E2C": "ce "
+    "\u6E2D": "wei "
+    "\u6E2F": "gang "
+    "\u6E34": "ke "
+    "\u6E38": "you "
+    "\u6E3A": "Miao "
+    "\u6E3E": "hun "
+    "\u6E44": "mei "
+    "\u6E51": "xu "
+    "\u6E56": "hu "
+    "\u6E58": "Xiang "
+    "\u6E5B": "Zhan "
+    "\u6E6F": "tang "
+    "\u6E7E": "wan "
+    "\u6E7F": "shi "
+    "\u6E89": "gai "
+    "\u6E90": "yuan "
+    "\u6E96": "zhun "
+    "\u6E9C": "liu "
+    "\u6E9D": "gou "
+    "\u6E9F": "ming "
+    "\u6EA2": "yi "
+    "\u6EA5": "Pu "
+    "\u6EAA": "xi "
+    "\u6EAB": "wen "
+    "\u6EAF": "su "
+    "\u6EB6": "rong "
+    "\u6EC4": "cang "
+    "\u6EC5": "mie "
+    "\u6EC7": "dian "
+    "\u6ECB": "zi "
+    "\u6ECC": "Di "
+    "\u6ED1": "hua "
+    "\u6ED5": "teng "
+    "\u6EDA": "gun "
+    "\u6EE1": "man "
+    "\u6EE2": "Ying "
+    "\u6EE5": "lan "
+    "\u6EE8": "bin "
+    "\u6EE9": "tan "
+    "\u6EEC": "hu "
+    "\u6EF4": "di "
+    "\u6EF8": "hu "
+    "\u6EFF": "man "
+    "\u6F01": "yu "
+    "\u6F02": "piao "
+    "\u6F06": "qi "
+    "\u6F0F": "lou "
+    "\u6F13": "Li "
+    "\u6F14": "yan "
+    "\u6F15": "cao "
+    "\u6F20": "mo "
+    "\u6F22": "han "
+    "\u6F29": "xuan "
+    "\u6F2A": "Yi "
+    "\u6F2B": "man "
+    "\u6F31": "Shuming "
+    "\u6F33": "zhang "
+    "\u6F47": "xiao "
+    "\u6F4D": "wei "
+    "\u6F54": "jie "
+    "\u6F58": "pan "
+    "\u6F5B": "qian "
+    "\u6F5C": "qian "
+    "\u6F5E": "Lu "
+    "\u6F62": "huang "
+    "\u6F64": "Run "
+    "\u6F6D": "tan "
+    "\u6F6E": "chao "
+    "\u6F84": "cheng "
+    "\u6F8D": "shu "
+    "\u6F8E": "peng "
+    "\u6F94": "hao "
+    "\u6F97": "jian "
+    "\u6F9C": "Lan "
+    "\u6FA4": "Ze "
+    "\u6FA7": "li "
+    "\u6FB3": "ao "
+    "\u6FB9": "Dan lu "
+    "\u6FC0": "ji "
+    "\u6FC1": "zhuo "
+    "\u6FC2": "lian "
+    "\u6FC3": "nong "
+    "\u6FD2": "bin "
+    "\u6FDF": "ji "
+    "\u6FE0": "hao "
+    "\u6FE4": "tao "
+    "\u6FEC": "xun "
+    "\u6FEE": "pu "
+    "\u6FF0": "wei "
+    "\u6FF1": "bin "
+    "\u6FF3": "Qian "
+    "\u700B": "Shen "
+    "\u700F": "liu "
+    "\u7011": "Pu "
+    "\u701A": "han "
+    "\u701B": "ying "
+    "\u701D": "li "
+    "\u701F": "Xiao "
+    "\u7032": "lian "
+    "\u704B": "fa "
+    "\u704C": "guan "
+    "\u704F": "hao "
+    "\u7051": "sa "
+    "\u705D": "hao "
+    "\u7063": "wan "
+    "\u7067": "yan "
+    "\u706B": "huo "
+    "\u706D": "mie "
+    "\u706F": "deng "
+    "\u7070": "hui "
+    "\u7075": "ling "
+    "\u7076": "zao "
+    "\u7078": "jiu "
+    "\u707D": "zai "
+    "\u707E": "zai "
+    "\u707F": "can "
+    "\u7081": "qi "
+    "\u7089": "lu "
+    "\u708E": "yan "
+    "\u7092": "chao "
+    "\u709C": "Wei "
+    "\u70AB": "xuan "
+    "\u70AC": "ju "
+    "\u70AD": "tan "
+    "\u70AE": "pao "
+    "\u70AF": "jiong "
+    "\u70B3": "bing "
+    "\u70B8": "zha "
+    "\u70B9": "dian "
+    "\u70BA": "wei "
+    "\u70BC": "lian "
+    "\u70C2": "lan "
+    "\u70C8": "lie "
+    "\u70CF": "wu "
+    "\u70D9": "luo "
+    "\u70DB": "zhu "
+    "\u70DC": "xuan "
+    "\u70DF": "yan "
+    "\u70E4": "kao "
+    "\u70E6": "fan "
+    "\u70E7": "shao "
+    "\u70E8": "ye "
+    "\u70ED": "re "
+    "\u70F1": "jiong "
+    "\u70FD": "feng "
+    "\u710A": "han "
+    "\u7115": "huan "
+    "\u7118": "tao "
+    "\u711A": "fen "
+    "\u711C": "Kun "
+    "\u7121": "wu "
+    "\u7126": "jiao "
+    "\u712F": "Zhuo "
+    "\u7130": "yan "
+    "\u7131": "yan "
+    "\u7136": "ran "
+    "\u7141": "chen "
+    "\u7147": "hui "
+    "\u7149": "Lian "
+    "\u714A": "xuan "
+    "\u714C": "huang "
+    "\u7152": "Wei "
+    "\u7159": "yan "
+    "\u715C": "yu "
+    "\u715E": "sha "
+    "\u7164": "mei "
+    "\u7165": "huan "
+    "\u7166": "xu "
+    "\u7167": "zhao "
+    "\u7169": "fan "
+    "\u716C": "Yang "
+    "\u716E": "zhu "
+    "\u718A": "xiong "
+    "\u7199": "xi "
+    "\u719F": "shu "
+    "\u71A0": "yi "
+    "\u71A4": "yi "
+    "\u71B1": "re "
+    "\u71B9": "xi "
+    "\u71BE": "chi "
+    "\u71C3": "ran "
+    "\u71C8": "deng "
+    "\u71C9": "dun "
+    "\u71CA": "shen "
+    "\u71D2": "shao "
+    "\u71D5": "yan "
+    "\u71DF": "ying "
+    "\u71E5": "zao "
+    "\u71E6": "can "
+    "\u71E7": "sui "
+    "\u71EE": "xie "
+    "\u71FF": "Yao "
+    "\u7206": "bao "
+    "\u720D": "shuo "
+    "\u721B": "lan "
+    "\u7228": "cuan "
+    "\u722C": "pa "
+    "\u722D": "zheng "
+    "\u7231": "ai "
+    "\u7232": "wei "
+    "\u7235": "jue "
+    "\u7236": "fu "
+    "\u7237": "ye "
+    "\u7238": "ba "
+    "\u7239": "die "
+    "\u723A": "ye "
+    "\u723B": "yao "
+    "\u723D": "shuang "
+    "\u723E": "er "
+    "\u7240": "chuang "
+    "\u7247": "pian "
+    "\u7248": "ban "
+    "\u724B": "jian "
+    "\u724C": "pai "
+    "\u7258": "du "
+    "\u7259": "ya "
+    "\u725B": "niu "
+    "\u725F": "Mu "
+    "\u7261": "mu "
+    "\u7262": "lao "
+    "\u7267": "mu "
+    "\u7269": "wu "
+    "\u7272": "sheng "
+    "\u7275": "qian "
+    "\u7279": "te "
+    "\u727A": "xi "
+    "\u727D": "qian "
+    "\u7280": "xi "
+    "\u7281": "Li "
+    "\u72AC": "quan "
+    "\u72AF": "fan "
+    "\u72B6": "zhuang "
+    "\u72B9": "you "
+    "\u72C0": "zhuang "
+    "\u72C2": "kuang "
+    "\u72C4": "Di "
+    "\u72D0": "hu "
+    "\u72D7": "gou "
+    "\u72DE": "ning "
+    "\u72E0": "hen "
+    "\u72EC": "du "
+    "\u72ED": "xia "
+    "\u72EE": "shi "
+    "\u72F1": "yu "
+    "\u72F7": "Juan "
+    "\u72FC": "lang "
+    "\u730E": "lie "
+    "\u731B": "meng "
+    "\u731C": "cai "
+    "\u7325": "wei "
+    "\u732A": "zhu "
+    "\u732B": "mao "
+    "\u732E": "xian "
+    "\u7334": "hou "
+    "\u7336": "you "
+    "\u7337": "you "
+    "\u7344": "yu "
+    "\u7345": "shi "
+    "\u734E": "jiang "
+    "\u7352": "ao "
+    "\u7368": "du "
+    "\u7372": "huo "
+    "\u7378": "Shou "
+    "\u737B": "xian "
+    "\u7384": "xuan "
+    "\u7387": "lu "
+    "\u7389": "yu "
+    "\u738B": "wang "
+    "\u7391": "ji "
+    "\u7395": "gan "
+    "\u7396": "jiu "
+    "\u739B": "ma "
+    "\u739F": "min "
+    "\u73A5": "yue "
+    "\u73A9": "wan "
+    "\u73AB": "mei "
+    "\u73AE": "Wei "
+    "\u73AF": "huan "
+    "\u73B0": "xian "
+    "\u73B2": "ling "
+    "\u73B3": "Dai "
+    "\u73BA": "xi "
+    "\u73BB": "bo "
+    "\u73C2": "ke "
+    "\u73C5": "shen "
+    "\u73C9": "min "
+    "\u73CA": "shan "
+    "\u73CD": "zhen "
+    "\u73CE": "zhen "
+    "\u73CF": "Jue "
+    "\u73D0": "fa "
+    "\u73D1": "long "
+    "\u73E0": "zhu "
+    "\u73E9": "heng "
+    "\u73ED": "ban "
+    "\u73EE": "Pei "
+    "\u73F2": "hui "
+    "\u73FA": "jun "
+    "\u73FE": "xian "
+    "\u7401": "xuan "
+    "\u7403": "qiu "
+    "\u7405": "lang "
+    "\u7406": "li "
+    "\u7407": "xiu "
+    "\u7409": "liu "
+    "\u740A": "ya "
+    "\u740F": "Lian "
+    "\u7410": "suo "
+    "\u741B": "chen "
+    "\u7422": "zhuo "
+    "\u7425": "Hu "
+    "\u7426": "qi "
+    "\u7428": "Kun "
+    "\u742A": "qi "
+    "\u742C": "wan "
+    "\u742E": "cong "
+    "\u742F": "guan "
+    "\u7430": "yan "
+    "\u7433": "lin "
+    "\u7434": "qin "
+    "\u7439": "qin "
+    "\u743A": "fa "
+    "\u743C": "qiong "
+    "\u7444": "xuan "
+    "\u744A": "jian "
+    "\u744B": "wei "
+    "\u7455": "Xia "
+    "\u7459": "nao "
+    "\u745A": "hu "
+    "\u745B": "ying "
+    "\u745C": "Yu "
+    "\u745E": "rui "
+    "\u745F": "se "
+    "\u7460": "liu "
+    "\u7464": "yao "
+    "\u7469": "ying "
+    "\u746A": "ma "
+    "\u746F": "lang "
+    "\u7470": "gui "
+    "\u747E": "jin "
+    "\u7480": "cui "
+    "\u7481": "cong "
+    "\u7483": "li "
+    "\u7487": "xuan "
+    "\u748B": "zhang "
+    "\u748D": "hua "
+    "\u7490": "lu "
+    "\u7498": "lin "
+    "\u749C": "Huang "
+    "\u749E": "pu "
+    "\u749F": "jing "
+    "\u74A0": "fan "
+    "\u74A7": "bi "
+    "\u74A8": "can "
+    "\u74B0": "huan "
+    "\u74B2": "sui "
+    "\u74BD": "xi "
+    "\u74CA": "qiong "
+    "\u74D2": "Zan "
+    "\u74D8": "guan "
+    "\u74DA": "Zan "
+    "\u74DC": "gua "
+    "\u74E6": "wa "
+    "\u74F6": "ping "
+    "\u74F7": "ci "
+    "\u7504": "zhen "
+    "\u750C": "Ou "
+    "\u7518": "gan "
+    "\u751A": "shen "
+    "\u751C": "tian "
+    "\u751F": "sheng "
+    "\u7522": "chan "
+    "\u7523": "chan "
+    "\u7526": "su "
+    "\u7528": "yong "
+    "\u7529": "shuai "
+    "\u752B": "fu "
+    "\u752C": "Yong "
+    "\u752F": "ning "
+    "\u7530": "tian "
+    "\u7531": "you "
+    "\u7532": "jia "
+    "\u7533": "shen "
+    "\u7535": "dian "
+    "\u7537": "nan "
+    "\u7538": "dian "
+    "\u753B": "hua "
+    "\u7545": "chang "
+    "\u754C": "jie "
+    "\u754F": "wei "
+    "\u7554": "pan "
+    "\u7559": "liu "
+    "\u755C": "xu "
+    "\u755D": "mu "
+    "\u7562": "bi "
+    "\u7564": "zhi "
+    "\u7565": "lue "
+    "\u7567": "lue "
+    "\u756A": "fan "
+    "\u756B": "hua "
+    "\u756C": "yu "
+    "\u7570": "yi "
+    "\u7572": "she "
+    "\u7576": "dang "
+    "\u757F": "ji "
+    "\u7586": "jiang "
+    "\u7587": "chou "
+    "\u758F": "shu "
+    "\u7591": "yi "
+    "\u7597": "liao "
+    "\u75AB": "yi "
+    "\u75AF": "feng "
+    "\u75B2": "pi "
+    "\u75B5": "ci "
+    "\u75B8": "dan "
+    "\u75BC": "teng "
+    "\u75BE": "ji "
+    "\u75C5": "bing "
+    "\u75C7": "zheng "
+    "\u75D5": "hen "
+    "\u75DB": "tong "
+    "\u75F4": "chi "
+    "\u761F": "wen "
+    "\u7624": "liu "
+    "\u7626": "shou "
+    "\u7642": "liao "
+    "\u764C": "ai "
+    "\u7661": "chi "
+    "\u7678": "gui "
+    "\u767B": "deng "
+    "\u767C": "fa "
+    "\u767D": "bai "
+    "\u767E": "bai "
+    "\u7684": "de "
+    "\u7686": "jie "
+    "\u7687": "huang "
+    "\u768B": "gao "
+    "\u768E": "jiao "
+    "\u7693": "hao "
+    "\u7696": "Wan "
+    "\u769E": "Hao "
+    "\u76A5": "hao "
+    "\u76AE": "pi "
+    "\u76B1": "zhou "
+    "\u76C6": "pen "
+    "\u76C8": "ying "
+    "\u76CA": "yi "
+    "\u76D0": "yan "
+    "\u76D1": "jian "
+    "\u76D2": "he "
+    "\u76D6": "gai "
+    "\u76D7": "dao "
+    "\u76D8": "pan "
+    "\u76DB": "cheng "
+    "\u76DC": "dao "
+    "\u76DF": "meng "
+    "\u76E1": "jin "
+    "\u76E3": "Jian "
+    "\u76E4": "pan "
+    "\u76E7": "lu "
+    "\u76EA": "dang "
+    "\u76EE": "mu "
+    "\u76EF": "ding "
+    "\u76F2": "mang "
+    "\u76F4": "zhi "
+    "\u76F8": "xiang "
+    "\u76FC": "pan "
+    "\u76FE": "dun "
+    "\u7701": "sheng "
+    "\u7709": "mei "
+    "\u770B": "kan "
+    "\u771E": "zhen "
+    "\u771F": "zhen "
+    "\u7720": "mian "
+    "\u7727": "zhao "
+    "\u7738": "mou "
+    "\u773A": "tiao "
+    "\u773C": "yan "
+    "\u773E": "zhong "
+    "\u7740": "zhe "
+    "\u7741": "zheng "
+    "\u7747": "di "
+    "\u775B": "jing "
+    "\u7761": "shui "
+    "\u7762": "Sui "
+    "\u7763": "du "
+    "\u778E": "xia "
+    "\u77A5": "pie "
+    "\u77A7": "qiao "
+    "\u77AA": "deng "
+    "\u77AC": "shun "
+    "\u77B0": "kan "
+    "\u77BB": "zhan "
+    "\u77BF": "qu "
+    "\u77DB": "mao "
+    "\u77E3": "yi "
+    "\u77E5": "zhi "
+    "\u77E9": "ju "
+    "\u77ED": "duan "
+    "\u77EE": "ai "
+    "\u77F3": "shi "
+    "\u77FF": "kuang "
+    "\u7801": "ma "
+    "\u7802": "sha "
+    "\u780D": "kan "
+    "\u7814": "yan "
+    "\u7816": "zhuan "
+    "\u781A": "Yan "
+    "\u7825": "Di "
+    "\u7834": "po "
+    "\u7838": "za "
+    "\u783A": "li "
+    "\u7840": "chu "
+    "\u7843": "zhu "
+    "\u784F": "yan "
+    "\u7855": "shuo "
+    "\u785D": "xiao "
+    "\u786C": "ying "
+    "\u786E": "que "
+    "\u786F": "yan "
+    "\u788C": "lu "
+    "\u788D": "ai "
+    "\u788E": "sui "
+    "\u7891": "bei "
+    "\u7897": "wan "
+    "\u789F": "die "
+    "\u78A7": "bi "
+    "\u78A9": "shuo "
+    "\u78B0": "peng "
+    "\u78B3": "tan "
+    "\u78BA": "que "
+    "\u78BC": "ma "
+    "\u78BE": "nian "
+    "\u78C1": "ci "
+    "\u78CA": "lei "
+    "\u78D5": "ke "
+    "\u78DA": "Zhuan "
+    "\u78E7": "qi "
+    "\u78E8": "mo "
+    "\u78EF": "ji "
+    "\u78FA": "Huang "
+    "\u7901": "jiao "
+    "\u790E": "chu "
+    "\u7926": "kuang "
+    "\u793A": "shi "
+    "\u793C": "li "
+    "\u793D": "Reng "
+    "\u793E": "she "
+    "\u7940": "si "
+    "\u7941": "Qi "
+    "\u7948": "qi "
+    "\u7950": "you "
+    "\u7955": "mi "
+    "\u7956": "zu "
+    "\u795A": "zuo "
+    "\u795C": "hu "
+    "\u795D": "zhu "
+    "\u795E": "shen "
+    "\u7960": "ci "
+    "\u7965": "xiang "
+    "\u7968": "piao "
+    "\u796D": "ji "
+    "\u796F": "Zhen "
+    "\u7978": "huo "
+    "\u797A": "Qi "
+    "\u797F": "lu "
+    "\u7981": "jin "
+    "\u7984": "lu "
+    "\u7985": "chan "
+    "\u798E": "zhen "
+    "\u798F": "fu "
+    "\u7995": "Yi "
+    "\u79A7": "xi "
+    "\u79AA": "chan "
+    "\u79AE": "li "
+    "\u79B1": "dao "
+    "\u79B9": "yu "
+    "\u79BA": "yu "
+    "\u79BB": "li "
+    "\u79BD": "qin "
+    "\u79BE": "he "
+    "\u79C0": "xiu "
+    "\u79C1": "si "
+    "\u79C3": "tu "
+    "\u79C9": "bing "
+    "\u79CB": "qiu "
+    "\u79CD": "zhong "
+    "\u79D1": "ke "
+    "\u79D2": "miao "
+    "\u79D8": "mi "
+    "\u79DF": "zu "
+    "\u79E6": "qin "
+    "\u79E9": "zhi "
+    "\u79EF": "ji "
+    "\u79F0": "cheng "
+    "\u79FB": "yi "
+    "\u7A00": "xi "
+    "\u7A05": "shui "
+    "\u7A0A": "ti "
+    "\u7A0B": "cheng "
+    "\u7A0D": "shao "
+    "\u7A0E": "shui "
+    "\u7A17": "bai "
+    "\u7A1A": "zhi "
+    "\u7A1C": "Leng "
+    "\u7A23": "su "
+    "\u7A2E": "chong "
+    "\u7A31": "cheng "
+    "\u7A33": "wen "
+    "\u7A37": "ji "
+    "\u7A3B": "dao "
+    "\u7A3C": "jia "
+    "\u7A3D": "ji "
+    "\u7A3F": "gao "
+    "\u7A40": "gu "
+    "\u7A46": "mu "
+    "\u7A4C": "su "
+    "\u7A4D": "ji "
+    "\u7A4E": "ying "
+    "\u7A57": "sui "
+    "\u7A74": "xue "
+    "\u7A76": "jiu "
+    "\u7A77": "qiong "
+    "\u7A79": "qiong "
+    "\u7A7A": "kong "
+    "\u7A7F": "chuan "
+    "\u7A81": "tu "
+    "\u7A83": "qie "
+    "\u7A91": "yao "
+    "\u7A96": "jiao "
+    "\u7A97": "chuang "
+    "\u7A9D": "wo "
+    "\u7A9F": "ku "
+    "\u7AA6": "Dou "
+    "\u7AAE": "qiang "
+    "\u7AAF": "yao "
+    "\u7AC4": "cuan "
+    "\u7ACB": "li "
+    "\u7AD1": "hong "
+    "\u7AD6": "shu "
+    "\u7AD9": "zhan "
+    "\u7ADE": "jing "
+    "\u7ADF": "jing "
+    "\u7AE0": "zhang "
+    "\u7AE5": "tong "
+    "\u7AEB": "Jing "
+    "\u7AED": "jie "
+    "\u7AEF": "duan "
+    "\u7AF6": "jing "
+    "\u7AF9": "zhu "
+    "\u7B03": "Du "
+    "\u7B08": "ji "
+    "\u7B11": "xiao "
+    "\u7B14": "bi "
+    "\u7B19": "sheng "
+    "\u7B1B": "di "
+    "\u7B20": "li "
+    "\u7B26": "fu "
+    "\u7B2A": "da "
+    "\u7B2C": "di "
+    "\u7B39": "shi "
+    "\u7B3C": "long "
+    "\u7B46": "bi "
+    "\u7B49": "deng "
+    "\u7B4B": "jin "
+    "\u7B4D": "sun "
+    "\u7B51": "zhu "
+    "\u7B52": "tong "
+    "\u7B54": "da "
+    "\u7B56": "ce "
+    "\u7B60": "yun "
+    "\u7B6E": "shi "
+    "\u7B71": "Xiao "
+    "\u7B79": "chou "
+    "\u7B7E": "qian "
+    "\u7B80": "jian "
+    "\u7B8B": "jian "
+    "\u7B8E": "chi "
+    "\u7B8F": "zheng "
+    "\u7B97": "suan "
+    "\u7BA1": "guan "
+    "\u7BAD": "jian "
+    "\u7BB1": "xiang "
+    "\u7BB4": "zhen "
+    "\u7BC0": "jie "
+    "\u7BC4": "fan "
+    "\u7BC6": "zhuan "
+    "\u7BC7": "pian "
+    "\u7BC9": "zhu "
+    "\u7BE4": "du "
+    "\u7BEA": "chi "
+    "\u7BEE": "lan "
+    "\u7C03": "yi "
+    "\u7C12": "cuan "
+    "\u7C21": "jian "
+    "\u7C23": "kui "
+    "\u7C27": "huang "
+    "\u7C2A": "Zan "
+    "\u7C37": "yan "
+    "\u7C3D": "qian "
+    "\u7C3F": "bu "
+    "\u7C4C": "chou "
+    "\u7C4D": "ji "
+    "\u7C5B": "Jian "
+    "\u7C5F": "lai "
+    "\u7C73": "mi "
+    "\u7C7B": "lei "
+    "\u7C89": "fen "
+    "\u7C92": "li "
+    "\u7C97": "cu "
+    "\u7C9F": "su "
+    "\u7CA4": "yue "
+    "\u7CA5": "zhou "
+    "\u7CAE": "liang "
+    "\u7CB1": "Liang "
+    "\u7CB2": "Can "
+    "\u7CB3": "jing "
+    "\u7CB9": "cui "
+    "\u7CBE": "jing "
+    "\u7CCA": "hu "
+    "\u7CD5": "gao "
+    "\u7CD6": "tang "
+    "\u7CDC": "mi "
+    "\u7CDF": "zao "
+    "\u7CE7": "liang "
+    "\u7CFB": "xi "
+    "\u7CFE": "jiu fen "
+    "\u7D00": "ji "
+    "\u7D04": "yue "
+    "\u7D05": "hong "
+    "\u7D0B": "wen "
+    "\u7D0D": "na "
+    "\u7D10": "niu "
+    "\u7D14": "chun "
+    "\u7D19": "zhi "
+    "\u7D1A": "ji "
+    "\u7D1B": "fen "
+    "\u7D20": "su "
+    "\u7D22": "suo "
+    "\u7D27": "jin "
+    "\u7D2B": "zi "
+    "\u7D2C": "chou "
+    "\u7D2F": "lei "
+    "\u7D30": "xi "
+    "\u7D31": "fu "
+    "\u7D33": "shen "
+    "\u7D39": "shao "
+    "\u7D42": "zhong "
+    "\u7D43": "xian "
+    "\u7D44": "zu "
+    "\u7D4C": "jing "
+    "\u7D50": "jie "
+    "\u7D55": "jue "
+    "\u7D5C": "Xie "
+    "\u7D61": "luo "
+    "\u7D66": "gei "
+    "\u7D68": "rong "
+    "\u7D6E": "xu "
+    "\u7D71": "tong "
+    "\u7D72": "si "
+    "\u7D73": "jiang "
+    "\u7D76": "jue "
+    "\u7D81": "bang "
+    "\u7D89": "xiu "
+    "\u7D8F": "sui "
+    "\u7D93": "jing "
+    "\u7D9C": "zong "
+    "\u7DA0": "lu "
+    "\u7DA2": "chou "
+    "\u7DAB": "xian "
+    "\u7DAC": "shou "
+    "\u7DAD": "wei "
+    "\u7DB1": "gang "
+    "\u7DB2": "wang "
+    "\u7DB5": "cai "
+    "\u7DB8": "lun "
+    "\u7DBA": "qi "
+    "\u7DBF": "mian "
+    "\u7DCA": "jin "
+    "\u7DCB": "fei "
+    "\u7DD2": "xu "
+    "\u7DD6": "xu "
+    "\u7DDA": "xian "
+    "\u7DDD": "ji "
+    "\u7DE3": "yuan "
+    "\u7DE8": "bian "
+    "\u7DEC": "Mian "
+    "\u7DEF": "wei "
+    "\u7DF4": "lian "
+    "\u7DF9": "ti "
+    "\u7DFB": "zhi "
+    "\u7E02": "zong "
+    "\u7E09": "jin "
+    "\u7E23": "xian "
+    "\u7E2B": "feng "
+    "\u7E2E": "suo "
+    "\u7E31": "zong "
+    "\u7E3D": "zong "
+    "\u7E3E": "ji "
+    "\u7E41": "fan "
+    "\u7E46": "Miao "
+    "\u7E54": "zhi "
+    "\u7E55": "shan "
+    "\u7E69": "sheng "
+    "\u7E6A": "hui "
+    "\u7E6B": "xi "
+    "\u7E79": "yi "
+    "\u7E7C": "ji "
+    "\u7E82": "zuan "
+    "\u7E8C": "xu "
+    "\u7E96": "xian "
+    "\u7E98": "zuan "
+    "\u7EA0": "jiu "
+    "\u7EA2": "hong "
+    "\u7EA4": "xian "
+    "\u7EA6": "yue "
+    "\u7EA7": "ji "
+    "\u7EAA": "ji "
+    "\u7EAC": "wei "
+    "\u7EAF": "chun "
+    "\u7EB1": "sha "
+    "\u7EB2": "gang "
+    "\u7EB3": "na "
+    "\u7EB5": "zong "
+    "\u7EB6": "Lun "
+    "\u7EB7": "fen "
+    "\u7EB8": "zhi "
+    "\u7EB9": "wen "
+    "\u7EBA": "fang "
+    "\u7EBD": "niu "
+    "\u7EBF": "xian "
+    "\u7EC3": "lian "
+    "\u7EC4": "zu "
+    "\u7EC5": "shen "
+    "\u7EC6": "xi "
+    "\u7EC7": "zhi "
+    "\u7EC8": "zhong "
+    "\u7ECD": "shao "
+    "\u7ECE": "yi "
+    "\u7ECF": "jing "
+    "\u7ED1": "bang "
+    "\u7ED2": "rong "
+    "\u7ED3": "jie "
+    "\u7ED5": "rao "
+    "\u7ED8": "hui "
+    "\u7ED9": "gei "
+    "\u7EDA": "Xuan "
+    "\u7EDB": "Jiang "
+    "\u7EDC": "luo "
+    "\u7EDD": "jue "
+    "\u7EDF": "tong "
+    "\u7EE3": "xiu "
+    "\u7EE7": "ji "
+    "\u7EE9": "ji "
+    "\u7EEA": "xu "
+    "\u7EEB": "ling "
+    "\u7EED": "xu "
+    "\u7EEE": "qi "
+    "\u7EF3": "sheng "
+    "\u7EF4": "wei "
+    "\u7EF5": "mian "
+    "\u7EF6": "shou "
+    "\u7EF8": "chou "
+    "\u7EFC": "zong "
+    "\u7EFF": "lu "
+    "\u7F00": "zhui "
+    "\u7F04": "jian "
+    "\u7F05": "mian "
+    "\u7F10": "xian "
+    "\u7F13": "huan "
+    "\u7F16": "bian "
+    "\u7F18": "yuan "
+    "\u7F19": "jin "
+    "\u7F1D": "feng "
+    "\u7F20": "chan "
+    "\u7F24": "bin "
+    "\u7F29": "suo "
+    "\u7F2A": "Miao "
+    "\u7F34": "jiao "
+    "\u7F38": "gang "
+    "\u7F3A": "que "
+    "\u7F50": "guan "
+    "\u7F51": "wang "
+    "\u7F55": "han "
+    "\u7F57": "luo "
+    "\u7F5A": "fa "
+    "\u7F61": "Gang "
+    "\u7F62": "ba "
+    "\u7F69": "zhao "
+    "\u7F6A": "zui "
+    "\u7F6E": "zhi "
+    "\u7F70": "fa "
+    "\u7F72": "shu "
+    "\u7F77": "ba "
+    "\u7F81": "ji "
+    "\u7F85": "luo "
+    "\u7F86": "pi "
+    "\u7F88": "ji "
+    "\u7F8A": "yang "
+    "\u7F8C": "Qiang "
+    "\u7F8E": "mei "
+    "\u7F9E": "xiu "
+    "\u7FA1": "Xian "
+    "\u7FA3": "Qun "
+    "\u7FA4": "qun "
+    "\u7FA9": "yi "
+    "\u7FB2": "xi "
+    "\u7FBD": "yu "
+    "\u7FBF": "yi "
+    "\u7FC1": "weng "
+    "\u7FC5": "chi "
+    "\u7FCA": "yi "
+    "\u7FCE": "Ling "
+    "\u7FD2": "xi "
+    "\u7FD4": "xiang "
+    "\u7FD8": "qiao "
+    "\u7FDF": "di "
+    "\u7FE0": "cui "
+    "\u7FE1": "fei "
+    "\u7FEE": "he "
+    "\u7FF0": "han "
+    "\u7FF1": "Ao "
+    "\u7FF3": "yi "
+    "\u7FF9": "qiao "
+    "\u7FFA": "ao "
+    "\u7FFB": "fan "
+    "\u7FFC": "yi "
+    "\u7FFD": "hui "
+    "\u8000": "yao "
+    "\u8001": "lao "
+    "\u8003": "kao "
+    "\u8005": "zhe "
+    "\u8006": "qi "
+    "\u800C": "er "
+    "\u800D": "shua "
+    "\u8010": "nai "
+    "\u8015": "geng "
+    "\u8017": "hao "
+    "\u8018": "yun "
+    "\u8026": "ou "
+    "\u8033": "er "
+    "\u8036": "ye "
+    "\u8037": "Da "
+    "\u803B": "chi "
+    "\u803F": "Geng "
+    "\u8042": "Nie "
+    "\u804A": "liao "
+    "\u804C": "zhi "
+    "\u8054": "lian "
+    "\u8056": "sheng "
+    "\u8058": "pin "
+    "\u805A": "ju "
+    "\u805E": "wen "
+    "\u8069": "kui "
+    "\u806A": "cong "
+    "\u806F": "lian "
+    "\u8070": "cong "
+    "\u8072": "sheng "
+    "\u8076": "nie "
+    "\u8077": "zhi "
+    "\u807D": "ting "
+    "\u807F": "Yuqing "
+    "\u8083": "su "
+    "\u8085": "su "
+    "\u8086": "si "
+    "\u8087": "zhao "
+    "\u8089": "rou "
+    "\u808C": "ji "
+    "\u8096": "xiao "
+    "\u809A": "du "
+    "\u809D": "gan "
+    "\u80A0": "chang "
+    "\u80A1": "gu "
+    "\u80A4": "fu "
+    "\u80A5": "fei "
+    "\u80A9": "jian "
+    "\u80AF": "ken "
+    "\u80B2": "yu "
+    "\u80BA": "fei "
+    "\u80BF": "zhong "
+    "\u80C0": "zhang "
+    "\u80C1": "xie "
+    "\u80C3": "wei "
+    "\u80C4": "Zhou "
+    "\u80C6": "dan "
+    "\u80CC": "bei "
+    "\u80CE": "tai "
+    "\u80D6": "pang "
+    "\u80DC": "sheng "
+    "\u80DE": "bao "
+    "\u80E1": "hu "
+    "\u80E4": "Yin "
+    "\u80E5": "Xu "
+    "\u80F6": "jiao "
+    "\u80F8": "xiong "
+    "\u80FD": "neng "
+    "\u8102": "zhi "
+    "\u8105": "xie "
+    "\u8106": "cui "
+    "\u8108": "mai "
+    "\u8109": "mai "
+    "\u810F": "zang "
+    "\u8111": "nao "
+    "\u8116": "bo "
+    "\u811A": "jiao "
+    "\u812B": "tuo "
+    "\u8131": "tuo "
+    "\u8138": "lian "
+    "\u813E": "pi "
+    "\u814A": "la "
+    "\u8150": "fu "
+    "\u8154": "qiang "
+    "\u8155": "wan "
+    "\u8166": "nao "
+    "\u8170": "yao "
+    "\u8173": "jiao "
+    "\u8179": "fu "
+    "\u817E": "teng "
+    "\u817F": "tui "
+    "\u8180": "bang "
+    "\u819A": "fu "
+    "\u819C": "mo "
+    "\u819D": "xi "
+    "\u81A0": "jiao "
+    "\u81A8": "peng "
+    "\u81C2": "bi "
+    "\u81C9": "lian "
+    "\u81D8": "la "
+    "\u81E3": "chen "
+    "\u81E7": "zang "
+    "\u81E8": "lin "
+    "\u81EA": "zi "
+    "\u81ED": "chou "
+    "\u81F3": "zhi "
+    "\u81F4": "zhi "
+    "\u81FA": "tai "
+    "\u81FB": "zhen "
+    "\u8205": "jiu "
+    "\u8206": "yu "
+    "\u8207": "yu "
+    "\u8208": "xing "
+    "\u8209": "ju "
+    "\u820A": "jiu "
+    "\u820C": "she "
+    "\u820D": "she "
+    "\u8212": "shu "
+    "\u8218": "guan "
+    "\u821C": "shun "
+    "\u821E": "wu "
+    "\u821F": "zhou "
+    "\u822A": "hang "
+    "\u822C": "ban "
+    "\u8230": "jian "
+    "\u8235": "duo "
+    "\u8236": "bo "
+    "\u8239": "chuan "
+    "\u8247": "ting "
+    "\u8258": "sou "
+    "\u8259": "cang "
+    "\u826F": "liang "
+    "\u8270": "jian "
+    "\u8272": "se "
+    "\u8273": "yan "
+    "\u8277": "Yan "
+    "\u827A": "yi "
+    "\u827E": "ai "
+    "\u8282": "jie "
+    "\u8283": "peng "
+    "\u8291": "qi "
+    "\u8292": "mang "
+    "\u8297": "Xiang "
+    "\u8299": "fu "
+    "\u829C": "wu "
+    "\u829D": "zhi "
+    "\u82AC": "fen "
+    "\u82AD": "ba "
+    "\u82AE": "rui "
+    "\u82AF": "xin "
+    "\u82B1": "hua "
+    "\u82B3": "fang "
+    "\u82B6": " "
+    "\u82B7": "zhi "
+    "\u82B8": "yun "
+    "\u82B9": "qin "
+    "\u82BB": "chu "
+    "\u82BE": "Fu "
+    "\u82C7": "wei "
+    "\u82CD": "cang "
+    "\u82CF": "su "
+    "\u82D1": "yuan "
+    "\u82D3": "ling "
+    "\u82D5": "Tiao "
+    "\u82D7": "miao "
+    "\u82E0": "Mingang "
+    "\u82E5": "ruo "
+    "\u82E6": "ku "
+    "\u82EF": "ben "
+    "\u82F1": "ying "
+    "\u82F9": "ping "
+    "\u8302": "mao "
+    "\u8303": "fan "
+    "\u8305": "mao "
+    "\u830C": "chi "
+    "\u831C": "xi "
+    "\u8328": "ci "
+    "\u832B": "mang "
+    "\u8332": "zi "
+    "\u8335": "yin "
+    "\u8336": "cha "
+    "\u8339": "ru "
+    "\u8340": "xun "
+    "\u8346": "jing "
+    "\u8349": "cao "
+    "\u834A": "Jing "
+    "\u8350": "jian "
+    "\u8352": "huang "
+    "\u8354": "li "
+    "\u8358": "zhuang "
+    "\u835F": "hui "
+    "\u8361": "dang "
+    "\u8363": "rong "
+    "\u8365": "Xing "
+    "\u8369": "jin "
+    "\u836A": "sun "
+    "\u836B": "yin "
+    "\u836F": "yao "
+    "\u8377": "he "
+    "\u837C": "tu "
+    "\u8386": "pu "
+    "\u8389": "li "
+    "\u838A": "zhuang "
+    "\u838E": "sha "
+    "\u8392": "ju "
+    "\u8398": "xin "
+    "\u83AB": "mo "
+    "\u83B1": "lai "
+    "\u83B2": "lian "
+    "\u83B3": "shi "
+    "\u83B7": "huo "
+    "\u83B9": "Ying "
+    "\u83C1": "jing "
+    "\u83CA": "ju "
+    "\u83CC": "jun "
+    "\u83CF": "he "
+    "\u83DC": "cai "
+    "\u83E0": "Bo "
+    "\u83E9": "pu "
+    "\u83EF": "hua "
+    "\u83F1": "ling "
+    "\u83F2": "fei "
+    "\u83F4": "an "
+    "\u83F8": "Yan "
+    "\u8403": "cui "
+    "\u8404": "tao "
+    "\u840A": "lai "
+    "\u840C": "meng "
+    "\u840D": "ping "
+    "\u840E": "wei "
+    "\u841D": "luo "
+    "\u8425": "ying "
+    "\u8427": "xiao "
+    "\u8428": "sa "
+    "\u842C": "wan "
+    "\u8431": "xuan "
+    "\u843C": "e "
+    "\u843D": "luo "
+    "\u8446": "Bao "
+    "\u8449": "Ye "
+    "\u8457": "zhu "
+    "\u845B": "ge "
+    "\u8461": "pu "
+    "\u8463": "dong "
+    "\u8466": "wei "
+    "\u8469": "pa "
+    "\u846B": "hu "
+    "\u846C": "zang "
+    "\u846D": "jia "
+    "\u8471": "cong "
+    "\u8473": "wei "
+    "\u8475": "kui "
+    "\u8482": "di "
+    "\u848B": "Jiang "
+    "\u8490": "sou "
+    "\u8497": "lang "
+    "\u8499": "meng "
+    "\u84B2": "Pu "
+    "\u84B8": "zheng "
+    "\u84BC": "Cang "
+    "\u84C0": "sun "
+    "\u84C1": "zhen "
+    "\u84C4": "xu "
+    "\u84C9": "rong "
+    "\u84CB": "gai "
+    "\u84DD": "lan "
+    "\u84E6": "Mo "
+    "\u84EC": "peng "
+    "\u84EE": "lian "
+    "\u84FC": "liao "
+    "\u8513": "man "
+    "\u851A": "wei "
+    "\u8521": "Cai "
+    "\u8523": "jiang "
+    "\u852C": "shu "
+    "\u852D": "yin "
+    "\u8535": "cang "
+    "\u8537": "Qiang "
+    "\u853A": "Lin "
+    "\u853C": "Ai "
+    "\u8549": "Jiao "
+    "\u854A": "rui "
+    "\u8569": "dang "
+    "\u856A": "Wu "
+    "\u856D": "xiao "
+    "\u857E": "lei "
+    "\u8580": "yun "
+    "\u8584": "bao "
+    "\u8587": "wei "
+    "\u858C": "xiang "
+    "\u859B": "Xue "
+    "\u85A6": "jian "
+    "\u85A9": "pu "
+    "\u85AA": "xin "
+    "\u85AF": "zhu "
+    "\u85B0": "Xun "
+    "\u85C1": "gao "
+    "\u85C9": "ji "
+    "\u85CD": "lan "
+    "\u85CF": "cang "
+    "\u85D5": "Ou "
+    "\u85DD": "yi "
+    "\u85E4": "teng "
+    "\u85E5": "yao "
+    "\u85E9": "fan "
+    "\u85FA": "Lin "
+    "\u85FB": "zao "
+    "\u8605": "heng "
+    "\u8606": "Lu "
+    "\u8607": "su "
+    "\u860A": "yun "
+    "\u860B": "ping "
+    "\u8629": "Fan "
+    "\u862D": "lan "
+    "\u864E": "hu "
+    "\u8651": "lu "
+    "\u8655": "chu "
+    "\u865A": "xu "
+    "\u865B": "xu "
+    "\u865E": "yu "
+    "\u865F": "hao "
+    "\u866B": "chong "
+    "\u866C": "Qiu "
+    "\u8679": "hong "
+    "\u867D": "sui "
+    "\u867E": "xia "
+    "\u868C": "bang "
+    "\u8695": "can "
+    "\u86B5": "ke "
+    "\u86B6": "han "
+    "\u86C7": "she "
+    "\u86CB": "dan "
+    "\u86D9": "wa "
+    "\u86DB": "zhu "
+    "\u86DF": "jiao "
+    "\u86EE": "man "
+    "\u86FB": "tui "
+    "\u86FE": "e "
+    "\u8700": "shu "
+    "\u8702": "feng "
+    "\u8718": "zhi "
+    "\u871C": "mi "
+    "\u8721": "la "
+    "\u8755": "shi "
+    "\u8760": "fu "
+    "\u8774": "hu "
+    "\u8776": "die "
+    "\u8778": "Wo "
+    "\u878D": "rong "
+    "\u879E": "ma "
+    "\u87A2": "ying "
+    "\u87BA": "luo "
+    "\u87C0": "shuai "
+    "\u87CB": "xi "
+    "\u87F2": "chong "
+    "\u87FB": "yi "
+    "\u87FE": "chan "
+    "\u8821": "li "
+    "\u883B": "man "
+    "\u8840": "xue "
+    "\u8846": "zhong "
+    "\u884C": "xing "
+    "\u884D": "Yan "
+    "\u8853": "shu "
+    "\u8857": "jie "
+    "\u8859": "ya "
+    "\u885B": "wei "
+    "\u885D": "chong "
+    "\u8861": "heng "
+    "\u8862": "qu "
+    "\u8863": "yi "
+    "\u8865": "bu "
+    "\u8868": "biao "
+    "\u886B": "shan "
+    "\u886C": "chen "
+    "\u8870": "shuai "
+    "\u8877": "zhong "
+    "\u8881": "Yuan "
+    "\u888B": "dai "
+    "\u888D": "pao "
+    "\u8896": "xiu "
+    "\u88AB": "bei "
+    "\u88AD": "xi "
+    "\u88BE": "Zhu "
+    "\u88C1": "cai "
+    "\u88C2": "lie "
+    "\u88C5": "zhuang "
+    "\u88CF": "li "
+    "\u88D4": "yi "
+    "\u88D5": "yu "
+    "\u88D8": "Qiu "
+    "\u88D9": "qun "
+    "\u88DC": "bu "
+    "\u88DD": "zhuang "
+    "\u88E1": "li "
+    "\u88E4": "ku "
+    "\u88F1": "biao "
+    "\u88F4": "pei "
+    "\u88F9": "guo "
+    "\u88FD": "zhi "
+    "\u8907": "fu "
+    "\u8910": "he "
+    "\u8912": "Bao "
+    "\u891A": "chu "
+    "\u893B": "xie "
+    "\u8944": "xiang "
+    "\u894C": "chan "
+    "\u897F": "xi "
+    "\u8981": "yao "
+    "\u8983": "qin "
+    "\u8986": "fu "
+    "\u898B": "jian "
+    "\u898F": "gui "
+    "\u8996": "shi "
+    "\u899A": "jue "
+    "\u89AA": "qin "
+    "\u89AF": "Gou "
+    "\u89B2": "jin "
+    "\u89BA": "jue "
+    "\u89BD": "lan "
+    "\u89C0": "guan "
+    "\u89C1": "jian "
+    "\u89C2": "guan "
+    "\u89C4": "gui "
+    "\u89C6": "shi "
+    "\u89C8": "lan "
+    "\u89C9": "jue "
+    "\u89D2": "jiao "
+    "\u89D5": "cu "
+    "\u89E3": "jie "
+    "\u89E6": "chu "
+    "\u8A00": "yan "
+    "\u8A02": "ding "
+    "\u8A08": "ji "
+    "\u8A0A": "xun "
+    "\u8A0E": "tao "
+    "\u8A13": "xun "
+    "\u8A17": "tuo "
+    "\u8A18": "ji "
+    "\u8A1F": "song "
+    "\u8A23": "jue "
+    "\u8A2A": "fang "
+    "\u8A2D": "she "
+    "\u8A31": "Xu "
+    "\u8A34": "su "
+    "\u8A3A": "zhen "
+    "\u8A3B": "zhu "
+    "\u8A41": "gu "
+    "\u8A55": "ping "
+    "\u8A5E": "ci "
+    "\u8A60": "yong "
+    "\u8A62": "xun "
+    "\u8A66": "shi "
+    "\u8A69": "Shi "
+    "\u8A6D": "Gui "
+    "\u8A6E": "quan "
+    "\u8A70": "jie "
+    "\u8A71": "hua "
+    "\u8A72": "gai "
+    "\u8A73": "xiang "
+    "\u8A75": "shen "
+    "\u8A79": "zhan "
+    "\u8A89": "yu "
+    "\u8A8C": "zhi "
+    "\u8A8D": "ren "
+    "\u8A93": "shi "
+    "\u8A95": "dan "
+    "\u8A9E": "yu "
+    "\u8AA0": "cheng "
+    "\u8AA4": "wu "
+    "\u8AA5": "gao "
+    "\u8AA6": "song "
+    "\u8AAA": "shui "
+    "\u8AAC": "shuo "
+    "\u8AB0": "shei "
+    "\u8AB2": "ke "
+    "\u8ABC": "yi "
+    "\u8ABF": "diao "
+    "\u8AC4": "zhun "
+    "\u8AC7": "tan "
+    "\u8ACB": "qing "
+    "\u8AD2": "liang "
+    "\u8AD6": "lun "
+    "\u8ADC": "die "
+    "\u8AE4": "e "
+    "\u8AE6": "di "
+    "\u8AEB": "Jian1 "
+    "\u8AEE": "zi "
+    "\u8AF6": "Chen "
+    "\u8AF8": "zhu "
+    "\u8AFA": "yan "
+    "\u8AFE": "nuo "
+    "\u8B00": "Mou "
+    "\u8B02": "wei "
+    "\u8B0E": "mi "
+    "\u8B17": "bang "
+    "\u8B19": "qian "
+    "\u8B1B": "jiang "
+    "\u8B1D": "xie "
+    "\u8B20": "yao "
+    "\u8B21": "yao "
+    "\u8B2B": "Zhe "
+    "\u8B33": "ou "
+    "\u8B39": "jin "
+    "\u8B49": "zheng "
+    "\u8B58": "shi "
+    "\u8B5A": "tan "
+    "\u8B5C": "pu "
+    "\u8B66": "jing "
+    "\u8B6F": "yi "
+    "\u8B70": "yi "
+    "\u8B77": "hu "
+    "\u8B7D": "yu "
+    "\u8B80": "du "
+    "\u8B8A": "bian "
+    "\u8B93": "rang "
+    "\u8B96": "chen "
+    "\u8B9A": "zan "
+    "\u8BA1": "ji "
+    "\u8BA2": "ding "
+    "\u8BA4": "ren "
+    "\u8BA8": "tao "
+    "\u8BA9": "rang "
+    "\u8BAD": "xun "
+    "\u8BAE": "yi "
+    "\u8BAF": "xun "
+    "\u8BB0": "ji "
+    "\u8BB2": "jiang "
+    "\u8BB8": "xu "
+    "\u8BBA": "lun "
+    "\u8BBC": "song "
+    "\u8BBD": "feng "
+    "\u8BBE": "she "
+    "\u8BBF": "fang "
+    "\u8BC1": "zheng "
+    "\u8BC4": "ping "
+    "\u8BC6": "shi "
+    "\u8BC9": "su "
+    "\u8BCA": "zhen "
+    "\u8BCB": "di "
+    "\u8BCD": "ci "
+    "\u8BD1": "yi "
+    "\u8BD2": "yi "
+    "\u8BD5": "shi "
+    "\u8BD7": "shi "
+    "\u8BD8": "jie "
+    "\u8BDA": "cheng "
+    "\u8BDD": "hua "
+    "\u8BDE": "dan "
+    "\u8BE0": "quan "
+    "\u8BE2": "xun "
+    "\u8BE5": "gai "
+    "\u8BE6": "xiang "
+    "\u8BED": "yu "
+    "\u8BEF": "wu "
+    "\u8BF1": "you "
+    "\u8BF4": "shuo "
+    "\u8BF7": "qing "
+    "\u8BF8": "zhu "
+    "\u8BFA": "nuo "
+    "\u8BFB": "du "
+    "\u8BFE": "ke "
+    "\u8C01": "shui "
+    "\u8C03": "diao "
+    "\u8C05": "liang "
+    "\u8C08": "tan "
+    "\u8C0A": "yi "
+    "\u8C0B": "mou "
+    "\u8C0E": "huang "
+    "\u8C0F": "Jian "
+    "\u8C10": "xie "
+    "\u8C13": "wei "
+    "\u8C1F": "mo "
+    "\u8C22": "xie "
+    "\u8C26": "qian "
+    "\u8C28": "jin "
+    "\u8C2C": "miu "
+    "\u8C2D": "tan "
+    "\u8C31": "pu "
+    "\u8C37": "gu "
+    "\u8C3F": "xi "
+    "\u8C46": "dou "
+    "\u8C50": "feng "
+    "\u8C61": "xiang "
+    "\u8C6A": "hao "
+    "\u8C6B": "yu "
+    "\u8C79": "Bao "
+    "\u8C8C": "mao "
+    "\u8C93": "mao "
+    "\u8C9E": "Zhen "
+    "\u8CA1": "cai "
+    "\u8CA2": "gong "
+    "\u8CA7": "pin "
+    "\u8CA8": "huo "
+    "\u8CA9": "fan "
+    "\u8CAA": "tan "
+    "\u8CAB": "guan "
+    "\u8CAC": "ze "
+    "\u8CB3": "er "
+    "\u8CB4": "gui "
+    "\u8CB7": "mai "
+    "\u8CBB": "fei "
+    "\u8CBD": "Yi "
+    "\u8CBF": "mao "
+    "\u8CC0": "he "
+    "\u8CC1": "ben "
+    "\u8CC3": "lin "
+    "\u8CC7": "zi "
+    "\u8CC8": "jia "
+    "\u8CCA": "zei "
+    "\u8CD3": "bin "
+    "\u8CDE": "shang "
+    "\u8CE0": "pei "
+    "\u8CE1": "geng "
+    "\u8CE2": "xian "
+    "\u8CE3": "mai "
+    "\u8CE6": "fu "
+    "\u8CEA": "zhi "
+    "\u8CEC": "zhang "
+    "\u8CED": "du "
+    "\u8CF4": "lai "
+    "\u8CFC": "gou "
+    "\u8CFD": "Sai "
+    "\u8CFE": "ze "
+    "\u8D04": "Zhi "
+    "\u8D07": "Yun "
+    "\u8D08": "zeng "
+    "\u8D0A": "zan "
+    "\u8D0F": "ying "
+    "\u8D16": "shu "
+    "\u8D1B": "gan "
+    "\u8D1D": "bei "
+    "\u8D1E": "zhen "
+    "\u8D1F": "fu "
+    "\u8D21": "gong "
+    "\u8D22": "cai "
+    "\u8D23": "ze "
+    "\u8D24": "xian "
+    "\u8D25": "bai "
+    "\u8D26": "zhang "
+    "\u8D27": "huo "
+    "\u8D28": "zhi "
+    "\u8D29": "fan "
+    "\u8D2A": "tan "
+    "\u8D2B": "pin "
+    "\u8D2D": "gou "
+    "\u8D2F": "guan "
+    "\u8D30": "er "
+    "\u8D34": "tie "
+    "\u8D35": "gui "
+    "\u8D37": "dai "
+    "\u8D38": "mao "
+    "\u8D39": "fei "
+    "\u8D3A": "he "
+    "\u8D3B": "Yi "
+    "\u8D3C": "zei "
+    "\u8D3E": "gu "
+    "\u8D3F": "hui "
+    "\u8D41": "lin "
+    "\u8D44": "zi "
+    "\u8D49": "Lai "
+    "\u8D4B": "fu "
+    "\u8D4C": "du "
+    "\u8D4F": "shang "
+    "\u8D50": "ci "
+    "\u8D54": "pei "
+    "\u8D56": "lai "
+    "\u8D5A": "zhuan "
+    "\u8D5B": "sai "
+    "\u8D5E": "zan "
+    "\u8D60": "zeng "
+    "\u8D62": "ying "
+    "\u8D63": "gan "
+    "\u8D64": "chi "
+    "\u8D6B": "He "
+    "\u8D70": "zou "
+    "\u8D73": "jiu "
+    "\u8D74": "fu "
+    "\u8D75": "Zhao "
+    "\u8D76": "gan "
+    "\u8D77": "qi "
+    "\u8D81": "chen "
+    "\u8D85": "chao "
+    "\u8D8A": "yue "
+    "\u8D8B": "qu "
+    "\u8D99": "zhao "
+    "\u8D9F": "tang "
+    "\u8DA3": "qu "
+    "\u8DA8": "qu "
+    "\u8DB3": "zu "
+    "\u8DC3": "yue "
+    "\u8DCB": "ba "
+    "\u8DCC": "die "
+    "\u8DD1": "pao "
+    "\u8DDD": "ju "
+    "\u8DDF": "gen "
+    "\u8DE1": "ji "
+    "\u8DE8": "kua "
+    "\u8DEA": "gui "
+    "\u8DEF": "lu "
+    "\u8DF3": "tiao "
+    "\u8DF5": "jian "
+    "\u8E0F": "ta "
+    "\u8E10": "jian "
+    "\u8E22": "ti "
+    "\u8E29": "cai "
+    "\u8E2A": "zong "
+    "\u8E48": "dao "
+    "\u8E5F": "ji "
+    "\u8E64": "zong "
+    "\u8E72": "dun "
+    "\u8E8D": "yue "
+    "\u8EAB": "shen "
+    "\u8EB2": "duo "
+    "\u8EBA": "tang "
+    "\u8ECA": "che "
+    "\u8ECC": "gui "
+    "\u8ECD": "jun "
+    "\u8ED2": "xuan "
+    "\u8EDF": "ruan "
+    "\u8EF8": "zhou "
+    "\u8EFE": "shi "
+    "\u8F03": "jiao "
+    "\u8F09": "zai "
+    "\u8F14": "fu "
+    "\u8F15": "qing "
+    "\u8F1D": "hui "
+    "\u8F2F": "ji "
+    "\u8F38": "shu "
+    "\u8F3F": "yu "
+    "\u8F44": "xia "
+    "\u8F49": "zhuan "
+    "\u8F66": "che "
+    "\u8F68": "gui "
+    "\u8F69": "xuan "
+    "\u8F6C": "zhuan "
+    "\u8F6E": "lun "
+    "\u8F6F": "ruan "
+    "\u8F70": "hong "
+    "\u8F74": "zhou "
+    "\u8F76": "yi "
+    "\u8F7B": "qing "
+    "\u8F7C": "shi "
+    "\u8F7D": "zai "
+    "\u8F7F": "jiao "
+    "\u8F83": "jiao "
+    "\u8F85": "fu "
+    "\u8F86": "liang "
+    "\u8F88": "bei "
+    "\u8F89": "hui "
+    "\u8F90": "fu "
+    "\u8F91": "ji "
+    "\u8F93": "shu "
+    "\u8F9B": "xin "
+    "\u8F9C": "Gu "
+    "\u8F9E": "ci "
+    "\u8F9F": "bi "
+    "\u8FA3": "la "
+    "\u8FA6": "ban "
+    "\u8FA8": "bian "
+    "\u8FA9": "bian "
+    "\u8FAD": "ci "
+    "\u8FAF": "bian "
+    "\u8FB0": "chen "
+    "\u8FB1": "ru "
+    "\u8FB2": "nong "
+    "\u8FB9": "bian "
+    "\u8FBD": "liao "
+    "\u8FBE": "da "
+    "\u8FC1": "qian "
+    "\u8FC4": "qi "
+    "\u8FC5": "xun "
+    "\u8FC7": "guo "
+    "\u8FC8": "mai "
+    "\u8FCE": "ying "
+    "\u8FD0": "yun "
+    "\u8FD1": "jin "
+    "\u8FD4": "fan "
+    "\u8FD8": "hai "
+    "\u8FD9": "zhe "
+    "\u8FDB": "jin "
+    "\u8FDC": "yuan "
+    "\u8FDD": "wei "
+    "\u8FDE": "lian "
+    "\u8FDF": "chi "
+    "\u8FE5": "Jiong "
+    "\u8FEA": "di "
+    "\u8FEB": "po "
+    "\u8FF0": "shu "
+    "\u8FF7": "mi "
+    "\u8FF9": "ji "
+    "\u8FFA": "nai "
+    "\u8FFD": "zhui "
+    "\u9000": "tui "
+    "\u9001": "song "
+    "\u9002": "shi "
+    "\u9003": "tao "
+    "\u9006": "ni "
+    "\u9009": "xuan "
+    "\u900A": "xun "
+    "\u900D": "Xiao "
+    "\u900F": "tou "
+    "\u9010": "zhu "
+    "\u9012": "di "
+    "\u9014": "tu "
+    "\u9017": "dou "
+    "\u9019": "zhe "
+    "\u901A": "tong "
+    "\u901D": "shi "
+    "\u901F": "su "
+    "\u9020": "zao "
+    "\u9022": "feng "
+    "\u9023": "lian "
+    "\u9030": "you "
+    "\u9031": "zhou "
+    "\u9032": "jin "
+    "\u9035": "Kui "
+    "\u9038": "Yi "
+    "\u9039": "da "
+    "\u903B": "luo "
+    "\u903C": "bi "
+    "\u9042": "sui "
+    "\u9047": "yu "
+    "\u904A": "you "
+    "\u904B": "yun "
+    "\u904D": "bian "
+    "\u904E": "guo "
+    "\u904F": "e "
+    "\u9053": "dao "
+    "\u9054": "da "
+    "\u9055": "wei "
+    "\u9057": "yi "
+    "\u9059": "yao "
+    "\u905C": "xun "
+    "\u905E": "di "
+    "\u9060": "yuan "
+    "\u9063": "qian "
+    "\u9065": "yao "
+    "\u9069": "shi "
+    "\u906D": "zao "
+    "\u906E": "zhe "
+    "\u9072": "chi "
+    "\u9075": "zun "
+    "\u9077": "qian "
+    "\u9078": "xuan "
+    "\u907A": "yi "
+    "\u907C": "Liao "
+    "\u907F": "bi "
+    "\u9080": "yao "
+    "\u9081": "mai "
+    "\u9083": "sui "
+    "\u908A": "bian "
+    "\u908F": "luo "
+    "\u9091": "yi "
+    "\u9093": "Deng "
+    "\u9095": "Yong "
+    "\u909B": "qiong "
+    "\u90A0": "bin "
+    "\u90A2": "xing "
+    "\u90A3": "na "
+    "\u90A6": "bang "
+    "\u90AA": "xie "
+    "\u90AC": "Wu "
+    "\u90AE": "you "
+    "\u90AF": "Han "
+    "\u90B1": "qiu "
+    "\u90B3": "Pi "
+    "\u90B4": "Bing "
+    "\u90B5": "Shao "
+    "\u90B9": "zou "
+    "\u90BB": "lin "
+    "\u90C1": "yu "
+    "\u90CA": "jiao "
+    "\u90CE": "lang "
+    "\u90D0": "Kuai "
+    "\u90D1": "zheng "
+    "\u90DC": "Gao "
+    "\u90DD": "hao "
+    "\u90DF": "jia "
+    "\u90E1": "jun "
+    "\u90E2": "Ying "
+    "\u90E6": "li "
+    "\u90E7": "Yun "
+    "\u90E8": "bu "
+    "\u90ED": "guo "
+    "\u90EF": "tan "
+    "\u90F4": "Chen "
+    "\u90F5": "you "
+    "\u90F8": "dan "
+    "\u90FD": "dou "
+    "\u9102": "e "
+    "\u9106": "yun "
+    "\u9109": "xiang "
+    "\u9112": "zou "
+    "\u9114": "wu "
+    "\u911E": "Yin "
+    "\u9127": "deng "
+    "\u912D": "zheng "
+    "\u9131": "bo "
+    "\u913A": "Kuang "
+    "\u9149": "you "
+    "\u914D": "pei "
+    "\u9152": "jiu "
+    "\u916C": "chou "
+    "\u9171": "jiang "
+    "\u9177": "ku "
+    "\u9178": "suan "
+    "\u917F": "niang "
+    "\u9187": "chun "
+    "\u9189": "zui "
+    "\u9192": "xing "
+    "\u919C": "Chou "
+    "\u91AB": "yi "
+    "\u91AE": "jiao "
+    "\u91B4": "li "
+    "\u91C0": "niang "
+    "\u91C7": "cai "
+    "\u91CA": "shi "
+    "\u91CB": "shi "
+    "\u91CC": "li "
+    "\u91CD": "chong "
+    "\u91CE": "ye "
+    "\u91CF": "liang "
+    "\u91D1": "jin "
+    "\u91D7": "zhao "
+    "\u91DD": "Zhen "
+    "\u91E3": "Diao "
+    "\u920E": "gou "
+    "\u9210": "? "
+    "\u9214": "chao "
+    "\u921E": "jun "
+    "\u9234": "Ling "
+    "\u923A": "yu "
+    "\u9245": "Julang "
+    "\u925B": "qian "
+    "\u925E": "Yue "
+    "\u9274": "jian "
+    "\u9277": "hong "
+    "\u9280": "yin "
+    "\u9285": "tong "
+    "\u9293": "quan "
+    "\u9298": "ming "
+    "\u92AE": "luan "
+    "\u92B3": "rui "
+    "\u92B7": "xiao "
+    "\u92C3": "lang "
+    "\u92D0": "hong "
+    "\u92D2": "feng "
+    "\u92FC": "gang "
+    "\u9304": "lu "
+    "\u9310": "zhui "
+    "\u9318": "zhui "
+    "\u931A": "zheng "
+    "\u9322": "qian "
+    "\u9326": "jin "
+    "\u932B": "Xi "
+    "\u932F": "cuo "
+    "\u9354": "E "
+    "\u935A": "xi "
+    "\u9375": "jian "
+    "\u937E": "Zhong "
+    "\u9382": "mei "
+    "\u938C": "lian "
+    "\u938F": "liu "
+    "\u9397": "qiang "
+    "\u93A7": "kai "
+    "\u93AD": "zhen "
+    "\u93AE": "zhen "
+    "\u93C8": "lian "
+    "\u93D7": "keng "
+    "\u93D8": "qiang "
+    "\u93DC": "tang "
+    "\u93DE": "yong "
+    "\u93E1": "jing "
+    "\u93E4": "lou "
+    "\u9403": "? "
+    "\u9413": "dun "
+    "\u9418": "zhong "
+    "\u942B": "juan "
+    "\u9435": "tie "
+    "\u9438": "duo "
+    "\u9444": "zhu "
+    "\u9451": "jian "
+    "\u9452": "jian "
+    "\u9460": "Shuo "
+    "\u946B": "xin "
+    "\u947D": "zuan "
+    "\u947E": "luan "
+    "\u9488": "zhen "
+    "\u9489": "ding "
+    "\u948A": "zhao "
+    "\u9493": "diao "
+    "\u9497": "chai "
+    "\u949C": "ju "
+    "\u949E": "chao "
+    "\u949F": "zhong "
+    "\u94A2": "gang "
+    "\u94A6": "qin "
+    "\u94A7": "jun "
+    "\u94AE": "Niu "
+    "\u94B0": "Yu "
+    "\u94B1": "qian "
+    "\u94BB": "zuan "
+    "\u94BF": "dian "
+    "\u94C1": "tie "
+    "\u94C3": "ling "
+    "\u94C9": "Xuan "
+    "\u94DB": "dang "
+    "\u94DC": "tong "
+    "\u94DD": "lu¨ "
+    "\u94E8": "quan "
+    "\u94ED": "ming "
+    "\u94EE": "zheng "
+    "\u94F6": "yin "
+    "\u94F8": "Zhu "
+    "\u94FA": "pu "
+    "\u94FE": "lian "
+    "\u94FF": "Keng "
+    "\u9500": "xiao "
+    "\u9501": "suo "
+    "\u9505": "guo "
+    "\u950B": "feng "
+    "\u9510": "rui "
+    "\u9519": "cuo "
+    "\u9521": "xi "
+    "\u9526": "jin "
+    "\u952D": "ding "
+    "\u952E": "jian "
+    "\u9535": "qiang "
+    "\u9537": "e "
+    "\u953A": "Zhong "
+    "\u953B": "duan "
+    "\u9547": "zhen "
+    "\u954C": "juan "
+    "\u9550": "hao "
+    "\u9556": "biao "
+    "\u955B": "yong "
+    "\u955C": "jing "
+    "\u9576": "xiang "
+    "\u9577": "zhang "
+    "\u957F": "chang "
+    "\u9580": "men "
+    "\u9583": "shan "
+    "\u958B": "kai "
+    "\u958E": "hong "
+    "\u9592": "xian "
+    "\u9593": "jian "
+    "\u95A2": "guan "
+    "\u95A3": "ge "
+    "\u95A5": "fa "
+    "\u95A9": "min "
+    "\u95AC": "lang "
+    "\u95B1": "yue "
+    "\u95B2": "yue "
+    "\u95BB": "Yan "
+    "\u95C7": "an "
+    "\u95D5": "que "
+    "\u95D7": "guan "
+    "\u95DC": "guan "
+    "\u95E1": "chan "
+    "\u95E2": "pi "
+    "\u95E8": "men "
+    "\u95EA": "shan "
+    "\u95EB": "yan "
+    "\u95ED": "bi "
+    "\u95EE": "wen "
+    "\u95EF": "chuang "
+    "\u95F2": "xian "
+    "\u95F4": "jian "
+    "\u95F5": "min "
+    "\u95F7": "men "
+    "\u95F8": "zha "
+    "\u95F9": "nao "
+    "\u95FB": "wen "
+    "\u95FD": "min "
+    "\u9601": "ge "
+    "\u9605": "yue "
+    "\u960E": "yan "
+    "\u9614": "kuo "
+    "\u9619": "que "
+    "\u961A": "kan "
+    "\u961C": "fu "
+    "\u961F": "dui "
+    "\u9621": "qian "
+    "\u962E": "ruan "
+    "\u9632": "fang "
+    "\u9633": "yang "
+    "\u9634": "yin "
+    "\u9635": "zhen "
+    "\u9636": "jie "
+    "\u963B": "zu "
+    "\u963F": "a "
+    "\u9640": "tuo "
+    "\u9642": "bei "
+    "\u9644": "fu "
+    "\u9645": "ji "
+    "\u9646": "lu "
+    "\u9647": "long "
+    "\u9648": "chen "
+    "\u964C": "mo "
+    "\u964D": "jiang "
+    "\u9650": "xian "
+    "\u9655": "Shan "
+    "\u965C": "Shan "
+    "\u965D": "Shan "
+    "\u965E": "sheng "
+    "\u965F": "zhi "
+    "\u9662": "yuan "
+    "\u9664": "chu "
+    "\u9669": "xian "
+    "\u966A": "pei "
+    "\u966C": "zou "
+    "\u9670": "yin "
+    "\u9672": "shuo "
+    "\u9673": "chen "
+    "\u9675": "ling "
+    "\u9676": "tao "
+    "\u9677": "xian "
+    "\u9678": "lu "
+    "\u967D": "yang "
+    "\u9684": "ti "
+    "\u9686": "long "
+    "\u968A": "dui "
+    "\u968B": "sui "
+    "\u968D": "huang "
+    "\u968E": "jie "
+    "\u968F": "sui "
+    "\u9690": "yin "
+    "\u9694": "ge "
+    "\u9699": "xi "
+    "\u969B": "ji "
+    "\u969C": "zhang "
+    "\u96A7": "sui "
+    "\u96A8": "sui "
+    "\u96AA": "xian "
+    "\u96B0": "Xi "
+    "\u96B1": "yin "
+    "\u96B4": "long "
+    "\u96B6": "Li "
+    "\u96B8": "Li "
+    "\u96BE": "nan "
+    "\u96C0": "que "
+    "\u96C1": "yan "
+    "\u96C4": "xiong "
+    "\u96C5": "ya "
+    "\u96C6": "ji "
+    "\u96C7": "gu "
+    "\u96CB": "juan "
+    "\u96CD": "yong "
+    "\u96D5": "diao "
+    "\u96D9": "shuang "
+    "\u96DC": "za "
+    "\u96E2": "li "
+    "\u96E3": "nan "
+    "\u96E8": "yu "
+    "\u96EA": "xue "
+    "\u96EF": "wen "
+    "\u96F2": "yun "
+    "\u96F6": "ling "
+    "\u96F7": "lei "
+    "\u96FB": "dian "
+    "\u96FE": "wu "
+    "\u9700": "xu "
+    "\u9701": "ji "
+    "\u9704": "xiao "
+    "\u9706": "ting "
+    "\u9707": "zhen "
+    "\u9708": "Pei "
+    "\u9709": "mei "
+    "\u970D": "huo "
+    "\u970F": "fei "
+    "\u9713": "ni "
+    "\u9716": "lin "
+    "\u971C": "shuang "
+    "\u971E": "xia "
+    "\u9727": "Wu "
+    "\u9732": "lu "
+    "\u9738": "ba "
+    "\u9748": "ling "
+    "\u9751": "qing "
+    "\u9752": "qing "
+    "\u9756": "jing "
+    "\u9759": "jing "
+    "\u975C": "jing "
+    "\u975E": "fei "
+    "\u9760": "kao "
+    "\u9762": "mian "
+    "\u9769": "ge "
+    "\u9773": "Jin "
+    "\u9785": "Yang "
+    "\u978B": "xie "
+    "\u978D": "an "
+    "\u978F": "Gong "
+    "\u97A0": "ju "
+    "\u97AD": "bian "
+    "\u97CB": "wei "
+    "\u97D3": "han "
+    "\u97DC": "tao "
+    "\u97E6": "wei "
+    "\u97E7": "Ren "
+    "\u97E9": "Han "
+    "\u97EC": "tao "
+    "\u97F3": "yin "
+    "\u97F5": "yun "
+    "\u97F6": "shao "
+    "\u97FB": "yun "
+    "\u97FF": "xiang "
+    "\u9801": "ye "
+    "\u9802": "ding "
+    "\u9805": "xiang "
+    "\u9806": "shun "
+    "\u9808": "xu "
+    "\u980C": "song "
+    "\u9810": "yu "
+    "\u9812": "ban "
+    "\u9813": "dun "
+    "\u9818": "ling "
+    "\u9821": "jie "
+    "\u9824": "Yi "
+    "\u982B": "fu "
+    "\u982D": "tou "
+    "\u9839": "tui "
+    "\u983B": "pin "
+    "\u984C": "ti "
+    "\u984D": "e "
+    "\u984F": "yan "
+    "\u9854": "yan "
+    "\u9858": "yuan "
+    "\u985B": "dian "
+    "\u985E": "lei "
+    "\u9867": "gu "
+    "\u986F": "xian "
+    "\u9875": "ye "
+    "\u9876": "ding "
+    "\u9879": "xiang "
+    "\u987A": "shun "
+    "\u987B": "xu "
+    "\u987D": "wan "
+    "\u987E": "gu "
+    "\u987F": "dun "
+    "\u9881": "ban "
+    "\u9882": "song "
+    "\u9884": "yu "
+    "\u9886": "ling "
+    "\u9887": "po "
+    "\u9888": "jing "
+    "\u9889": "jie "
+    "\u9890": "yi "
+    "\u9891": "pin "
+    "\u9896": "ying "
+    "\u9897": "ke "
+    "\u9898": "ti "
+    "\u989C": "yan "
+    "\u989D": "e "
+    "\u98A0": "dian "
+    "\u98A4": "chan "
+    "\u98A8": "feng "
+    "\u98C4": "piao "
+    "\u98CE": "feng "
+    "\u98D8": "piao "
+    "\u98DB": "fei "
+    "\u98DE": "fei "
+    "\u98DF": "shi "
+    "\u98EE": "yin "
+    "\u98EF": "fan "
+    "\u98F2": "yin "
+    "\u98FE": "shi "
+    "\u990A": "yang "
+    "\u9910": "can "
+    "\u9918": "yu "
+    "\u9928": "guan "
+    "\u9952": "Rao "
+    "\u9957": "xiang "
+    "\u9965": "ji "
+    "\u996D": "fan "
+    "\u996E": "yin "
+    "\u9970": "shi "
+    "\u9971": "bao "
+    "\u9976": "rao "
+    "\u997C": "bing "
+    "\u997F": "e "
+    "\u9986": "guan "
+    "\u9996": "shou "
+    "\u9997": "Kui "
+    "\u9999": "xiang "
+    "\u99A8": "xin "
+    "\u99AC": "ma "
+    "\u99AD": "Yu "
+    "\u99AE": "feng "
+    "\u99B3": "chi "
+    "\u99C1": "bo "
+    "\u99D0": "zhu "
+    "\u99D2": "ju "
+    "\u99F1": "luo "
+    "\u99FF": "jun "
+    "\u9A0F": "qi "
+    "\u9A19": "pian "
+    "\u9A2B": "Qian "
+    "\u9A30": "teng "
+    "\u9A37": "sao "
+    "\u9A45": "qu "
+    "\u9A4A": "hua "
+    "\u9A55": "jiao "
+    "\u9A57": "yan "
+    "\u9A5A": "jing "
+    "\u9A64": "Xiang "
+    "\u9A65": "ji "
+    "\u9A6A": "li "
+    "\u9A6C": "ma "
+    "\u9A6D": "Yu "
+    "\u9A70": "chi "
+    "\u9A71": "qu "
+    "\u9A73": "bo "
+    "\u9A74": "Lu "
+    "\u9A76": "shi "
+    "\u9A7B": "zhu "
+    "\u9A7C": "tuo "
+    "\u9A7E": "jia "
+    "\u9A7F": "yi "
+    "\u9A81": "xiao "
+    "\u9A82": "ma "
+    "\u9A84": "jiao "
+    "\u9A85": "Hua "
+    "\u9A86": "luo "
+    "\u9A8A": "Li "
+    "\u9A8B": "cheng "
+    "\u9A8C": "yan "
+    "\u9A8F": "Jun "
+    "\u9A91": "qi "
+    "\u9A97": "pian "
+    "\u9A9A": "sao "
+    "\u9A9D": "liu "
+    "\u9A9E": "qian "
+    "\u9AA5": "ji "
+    "\u9AA8": "gu "
+    "\u9AB7": "ku "
+    "\u9ACF": "lou "
+    "\u9AD3": "sui "
+    "\u9AD4": "ti "
+    "\u9AD8": "gao "
+    "\u9AE0": "Kun "
+    "\u9AEA": "fa "
+    "\u9AEE": "fa "
+    "\u9B06": "song "
+    "\u9B1A": "xu "
+    "\u9B25": "dou "
+    "\u9B2F": "chang "
+    "\u9B31": "Yu "
+    "\u9B3C": "gui "
+    "\u9B41": "Kui "
+    "\u9B42": "hun "
+    "\u9B45": "mei "
+    "\u9B47": "yan "
+    "\u9B4F": "Wei "
+    "\u9B54": "mo "
+    "\u9B5A": "yu "
+    "\u9B6F": "Lu "
+    "\u9B80": "tuo "
+    "\u9B91": "Bao "
+    "\u9BAE": "xian "
+    "\u9BD3": "shen "
+    "\u9BE4": "kun "
+    "\u9C7C": "yu "
+    "\u9C81": "lu "
+    "\u9C8D": "bao "
+    "\u9C9C": "xian "
+    "\u9CA4": "li "
+    "\u9CCC": "ao "
+    "\u9CD6": "Bie "
+    "\u9CDE": "ling "
+    "\u9CE5": "niao "
+    "\u9CF3": "feng "
+    "\u9CF4": "ming "
+    "\u9D12": "ling "
+    "\u9D28": "ya "
+    "\u9D3B": "hong "
+    "\u9D3F": "ge "
+    "\u9D5D": "e "
+    "\u9D60": "gu "
+    "\u9D6C": "peng "
+    "\u9D77": "yuan "
+    "\u9DAF": "ying "
+    "\u9DB4": "he "
+    "\u9DBA": "ji "
+    "\u9DD7": "ou "
+    "\u9DDF": "zhuo "
+    "\u9DF9": "ying "
+    "\u9E1E": "luan "
+    "\u9E1F": "niao "
+    "\u9E21": "ji "
+    "\u9E23": "ming "
+    "\u9E25": "ou "
+    "\u9E2D": "ya "
+    "\u9E3D": "ge "
+    "\u9E3E": "luan "
+    "\u9E3F": "hong "
+    "\u9E42": "li "
+    "\u9E45": "E "
+    "\u9E4F": "peng "
+    "\u9E57": "e "
+    "\u9E64": "he "
+    "\u9E70": "ying "
+    "\u9E7D": "yan "
+    "\u9E7F": "lu "
+    "\u9E83": "biao "
+    "\u9E90": "lin "
+    "\u9E92": "qi "
+    "\u9E93": "Lu "
+    "\u9E97": "li "
+    "\u9E9F": "lin "
+    "\u9EA5": "mai "
+    "\u9EA6": "mai "
+    "\u9EBB": "ma "
+    "\u9EBC": "mo "
+    "\u9EBD": "mo "
+    "\u9EC3": "huang "
+    "\u9EC4": "huang "
+    "\u9ECC": "hong "
+    "\u9ECE": "li "
+    "\u9ED1": "hei "
+    "\u9ED4": "qian "
+    "\u9ED8": "mo "
+    "\u9EDB": "dai "
+    "\u9EDE": "dian "
+    "\u9EE8": "dang "
+    "\u9EEF": "An "
+    "\u9F0E": "ding "
+    "\u9F10": "nai "
+    "\u9F13": "gu "
+    "\u9F20": "shu "
+    "\u9F3B": "bi "
+    "\u9F4A": "qi "
+    "\u9F4B": "zhai "
+    "\u9F50": "qi "
+    "\u9F61": "ling "
+    "\u9F7F": "chi "
+    "\u9F84": "ling "
+    "\u9F8D": "long "
+    "\u9F90": "pang "
+    "\u9F94": "gong "
+    "\u9F95": "kan "
+    "\u9F99": "long "
+    "\u9F9A": "Gong "
+    "\u9F9C": "Gui "
+    "\u9F9F": "Qiu "
+    "\uFF01": "! "
+    "\uFF08": "("
+    "\uFF09": ") "
+    "\uFF0C": ", "
+    "\uFF0D": "- "
+    "\uFF0E": ". "
+    "\uFF0F": "/ "
+    "\uFF1A": ": "
+    "\uFF1B": "; "
+    "\uFF1F": "? "
+    "\uFF3B": "["
+    "\uFF3D": "] "

legacy/ReRomanizeRecord_nodbug.bas

@@ -0,0 +1,3423 @@
+Attribute VB_Name = "ReRomanize"
+Option Explicit
+
+#Const EvaluateFirstCharacterDebug = 0 ' -1 ' 0 ' -1 ' 0 ' -1
+#Const FindFieldCurrentlyPointedToDebug = 0 ' -1
+#Const ReRomanizeAdjustNFIDebug = 0 ' -1
+#Const ReRomanizeTextDebug = 0 ' -1 ' 0 ' -1  ' 0 ' -1 ' 0 ' -1 ' 0 ' -1
+#Const ReRomanizeTextDetailsDebug = 0 ' -1 ' 0 ' -1 ' 0 ' -1 ' 0 ' -1 ' 0 ' -1 ' 0 ' -1 ' 0 ' -1
+#Const ReRomanizeTextDetailsBasicsDebug = 0 ' -1 ' 0 ' -1 ' 0 ' -1 ' 0 ' -1 ' 0 ' -1 ' 0 ' -1
+#Const RomanizationAssistanceDebug = 0 ' -1 ' 0 ' -1 ' 0 ' -1 ' 0 ' -1
+#Const RomanizeHighlightedTextDebug = 0 ' -1
+#Const RomanizeWholeRecordDebug = 0 ' -1 ' 0 '-1
+
+' 20180926 Bucknum: added Unicode-compliant font constants for RTF formatting
+Private Const ArialUnicodeMS$ = "Arial Unicode MS"       ' Monotype
+Private Const LucidaSansUnicode$ = "Lucida Sans Unicode" ' Microsoft
+Private Const NotoSans$ = "Noto Sans"   ' Google
+Private Const NotoSerif$ = "Noto Serif" ' Google
+Private Const TextFormattedDefaultFont$ = ArialUnicodeMS$
+
+Private Const sAuthorityNonfilingString$ = "130:2 430:2 530:2"
+Private Const sBibliographicNonfilingString$ = "130:1 240:2 242:2 243:2 245:2 440:2 630:1 730:1 740:1 830:2"
+Private Const sCommunityInfoNonfilingString$ = "245:2 440:2 630:1 730:1 740:1"
+
+Private prvsRightToLeftMarker$, prvsLeftToRightMarker$
+
+Private Const CHARACTERSET_CODES_FOR_880_BasicAsG0$ = "(B"
+Private Const CHARACTERSET_CODES_FOR_880_HebrewAsG0$ = "(2"
+Private Const CHARACTERSET_CODES_FOR_880_BasicCyrillicAsG0$ = "(N"
+Private Const CHARACTERSET_CODES_FOR_880_BasicArabicAsG0$ = "(3"
+Private Const CHARACTERSET_CODES_FOR_880_GreekAsG0$ = "(S"
+Private Const CHARACTERSET_CODES_FOR_880_CJKAsG0$ = "$1"
+Private Const CHARACTERSET_CODES_FOR_880_ExtendedCyrillicAsG1$ = ")Q"
+Private Const CHARACTERSET_CODES_FOR_880_ExtendedArabicAsG1$ = ")4"
+Private Const CHARACTERSET_CODES_FOR_880_ExtendedLatinAsG1$ = ")!E"
+' convert this constant into its ASCII value subtract 48; and multiply this
+'   remainder by 6 to transform it into an offset into the following hyphen-delimited string
+' the first character (0) is the MARC-8'code table' number; same as above, with extensions
+' the second character (1) is the code to use for the set in non-880 fields after escape ("?"=illegal in non-880);
+' 4rd-5th chars (3-4) are the code to use after escape in 880 field
+' ignore other characters--turned out not to be needed
+'                                             1      2      3      4      5      6      7      8      9      :      ;
+'                                             012345 012345 012345 012345 012345 012345 012345 012345 012345 012345 012345
+Private Const CharSetU2MTranslation$ = "*****-1s s  -2g*g *-3b b  -4p p  -5? (2 -6? (N -7? (3 -8g*(S*-9? $1 -:? (Q -;? (4 "
+
+Global Const ROMANIZATIONACTION_DisplayMarcRecord% = 1
+Global Const ROMANIZATIONACTION_RomanizeHighlightedText% = 2
+Global Const ROMANIZATIONACTION_RomanizeWholeRecord% = 3
+Global Const ROMANIZATIONACTION_UCaseWord% = 4
+Global Const ROMANIZATIONACTION_LCaseWord% = 5
+Global Const ROMANIZATIONACTION_ReplaceText% = 6
+Global Const ROMANIZATIONACTION_UCaseEach% = 7
+Global Const ROMANIZATIONACTION_Define% = 8
+
+Enum RomanizationAction
+    DefineSubstitution = ROMANIZATIONACTION_Define%
+    DisplayMarcRecord = ROMANIZATIONACTION_DisplayMarcRecord%
+    LowercaseWord = ROMANIZATIONACTION_LCaseWord%
+    ReplaceText = ROMANIZATIONACTION_ReplaceText%
+    RomanizeHighlightedText = ROMANIZATIONACTION_RomanizeHighlightedText%
+    RomanizeWholeRecord = ROMANIZATIONACTION_RomanizeWholeRecord%
+    UppercaseWord = ROMANIZATIONACTION_UCaseWord%
+    UppercaseEachWord = ROMANIZATIONACTION_UCaseEach%
+End Enum
+
+Global Const ROMANIZATIONRESULT_Success% = 0
+Global Const ROMANIZATIONRESULT_TextNotHighlighted% = 1
+Global Const ROMANIZATIONRESULT_HighlightedTextBecomesNothing% = 2
+Global Const ROMANIZATIONRESULT_TextNotFindable% = 3
+Global Const ROMANIZATIONRESULT_ActionUnclear% = 4
+Global Const ROMANIZATIONRESULT_FieldNotFound% = 5
+Global Const ROMANIZATIONRESULT_880WithNoSubfield6% = 6
+Global Const ROMANIZATIONRESULT_880NotAllowed% = 7
+Global Const ROMANIZATIONRESULT_880AlreadyPresent% = 8
+Global Const ROMANIZATIONRESULT_NoCharacterToDefine% = 9
+Global Const ROMANIZATIONRESULT_FileOpen% = 10
+
+Global Const ROMANIZATIONDIRECTION_Unknown% = 0
+Global Const ROMANIZATIONDIRECTION_Roman2Vernacular% = 1
+Global Const ROMANIZATIONDIRECTION_Vernacular2Roman% = 2
+
+Type ROMANIZATIONDETAILTYPE
+    FullString As String
+    Equivalent As String
+    EquivalentUpperCase As String
+    FullStringLengthInCharacters As Integer
+    FullStringLengthInBytes As Integer
+    EquivalentUpperCasePresent As Boolean
+    InitialOnly As Boolean
+    TerminalOnly As Boolean
+    MedialOnly As Boolean
+End Type
+
+Type ROMANIZATIONDETAILARRAY
+    Detail() As ROMANIZATIONDETAILTYPE
+    DetailLast As Long
+    DetailMax As Long
+End Type
+
+Type ROMANIZATIONTABLETYPE
+    Vernacular2Roman As Object
+    Roman2Vernacular As Object
+    Name As String
+    FullFileName As String
+    Vernacular() As ROMANIZATIONDETAILARRAY
+    Roman() As ROMANIZATIONDETAILARRAY
+    VernacularLast As Long
+    VernacularMax As Long
+    RomanLast As Long
+    RomanMax As Long
+    AllowCaseVariation As Boolean
+    AllowDefineButton As Boolean
+    ApostropheCharacters As String
+    ApostropheCharactersPresent As Boolean
+    BySyllables As Boolean
+    DoNotUse880Field As Boolean
+    FontName As String
+    NoRomanization As Boolean
+    ' things that pertain only to romanized-to-vernacular
+    R2VCreateEmpty880s As Boolean
+    R2VFieldsIncluded As String
+    R2VIncludeFormattingCharactersLcPattern As Boolean
+    R2VOtherSubfieldsExcludedByTag As String
+    R2VSubfieldsAlwaysExcluded As String
+    R2VSubfield6Code As String
+    R2VVowelMarker As String
+    ' things that pertain only to vernacular-to-romanized
+    V2RCreateEmptyFields As Boolean
+    V2RFieldsIncluded As String
+    V2ROtherSubfieldsExcludedByTag As String
+    V2RSubfieldsAlwaysExcluded As String
+    V2RUppercaseFirstCharacterInSubfield As String
+    V2RPersonalNameUppercase As Boolean
+End Type
+
+Type RESEQUENCETABLETYPE
+    Tag As String * 3
+    LinkTag As String * 3
+    Field As String
+    Field880 As String
+    Sequence As Integer
+    Sequence880 As Integer
+End Type
+
+Public Type ROMANIZATIONSCRIPTTYPE
+    Name As String
+    LoadScript As Boolean
+    FileSize As Long
+End Type
+
+Global gblaReSequenceTable() As RESEQUENCETABLETYPE
+Global gblaRomanizationScript() As ROMANIZATIONSCRIPTTYPE
+Global gblaRomanizationTable() As ROMANIZATIONTABLETYPE
+Global gbliReSequenceTableLast%
+Global gbliRomanizationScriptLast%
+Global gbliRomanizationTableLast%, gbliRomanizationTableMax%
+Global gbliRomanizationTablesBytes#
+
+Public Function ReRomanizeText(ByVal sRecordType$, ByVal sTag$, ByVal sText$, ByVal iRomanizationTable%, ByRef LocalMarcRecordObject As Utf8MarcRecordClass, ByRef LocalMarcCharacter As Utf8CharClass, Optional ByRef iRomanizationDirection% = -1, Optional ByVal sSubfieldCode$ = "") As String
+
+    Dim sOut$, sLeft$, sRight$, sWord$
+    Dim iLength%
+    
+    Dim lPtr As Long, lLength As Long
+    
+    Dim bFound As Boolean
+    
+    
+    On Error GoTo 0
+        
+
+    If iRomanizationTable% < 1 Or iRomanizationTable% > gbliRomanizationTableLast% Then
+
+        sOut$ = sText$
+    Else
+        If iRomanizationDirection% = -1 Then
+            iRomanizationDirection% = EvaluateFirstCharacter(sText$, iRomanizationTable%, LocalMarcCharacter)
+
+        End If
+        Select Case iRomanizationDirection%
+            Case ROMANIZATIONDIRECTION_Unknown%
+                sOut$ = sText$
+            Case ROMANIZATIONDIRECTION_Roman2Vernacular%
+                sOut$ = ReRomanizeTextDetails(sText$, gblaRomanizationTable(iRomanizationTable%).Roman2Vernacular, gblaRomanizationTable(iRomanizationTable%).Roman(), LocalMarcRecordObject, LocalMarcCharacter, True, iRomanizationTable%)
+            Case ROMANIZATIONDIRECTION_Vernacular2Roman%
+                sOut$ = ReRomanizeTextDetails(sText$, gblaRomanizationTable(iRomanizationTable%).Vernacular2Roman, gblaRomanizationTable(iRomanizationTable%).Vernacular(), LocalMarcRecordObject, LocalMarcCharacter, False, iRomanizationTable%)
+
+                If gblaRomanizationTable(iRomanizationTable%).V2RPersonalNameUppercase Then
+                    ' todo: in reality, we should *only* add the comma if the first
+                    '   indicator is one or two (regardless of indicator, we should
+                    '   uppercase every word in the string)
+                    Select Case sRecordType$
+                        Case "A"
+                            If InStr("100 400 500", sTag$) > 0 Then
+ReRomanizeTextPersonalNameHandling:
+
+                                lPtr = InStr(sOut$, LocalMarcRecordObject.MarcDelimiter + "a")
+
+                                If lPtr > 0 Then
+                                    sLeft$ = Mid(sOut$, 1, lPtr + 1)
+                                    sOut$ = Mid(sOut$, lPtr + 2)
+                                ElseIf Mid(sOut$, 1, 1) = LocalMarcRecordObject.MarcDelimiter Then
+
+                                    GoTo ReRomanizeTextNoPNH
+                                Else
+                                    sLeft$ = ""
+                                End If
+                                lPtr = InStr(sOut$, LocalMarcRecordObject.MarcDelimiter)
+                                If lPtr > 0 Then
+                                    sRight$ = Mid(sOut$, lPtr)
+                                    sOut$ = Mid(sOut$, 1, lPtr - 1)
+                                Else
+                                    sRight$ = ""
+                                End If
+                                sOut$ = Trim(sOut$)
+
+                                ' first "word" in the heading remains as such
+                                lPtr = InStr(sOut$, " ")
+                                If lPtr > 0 Then
+                                    sLeft$ = sLeft$ + LocalMarcRecordObject.UCaseFirstWord(Mid(sOut$, 1, lPtr - 1) + ",")
+                                    sOut$ = Trim(Mid(sOut$, lPtr + 1))
+                                    Do While Len(sOut$) > 0
+                                        GetNextPiece sOut$, sWord$, " "
+                                        sLeft$ = sLeft$ + " " + LocalMarcRecordObject.UCaseFirstWord(sWord$)
+                                    Loop
+                                End If
+                                sOut$ = sLeft$ + sOut$ + sRight$
+                            End If
+ReRomanizeTextNoPNH:        ' NOTE label in left margin
+                        Case "B"
+                            If InStr("100 400 600 700 800", sTag$) > 0 Then
+                                GoTo ReRomanizeTextPersonalNameHandling
+                            End If
+                    End Select
+                End If
+                If Len(gblaRomanizationTable(iRomanizationTable%).V2RUppercaseFirstCharacterInSubfield) > 0 Then
+                    If InStr(gblaRomanizationTable(iRomanizationTable%).V2RUppercaseFirstCharacterInSubfield, sTag$) > 0 Then
+                        If InStr(sOut$, LocalMarcRecordObject.MarcDelimiter) > 0 Then
+                            ' potentially interesting
+                            For lPtr = Len(sOut$) - 2 To 1 Step -1
+                                If Mid(sOut$, lPtr, 1) = LocalMarcRecordObject.MarcDelimiter Then
+                                    If InStr(gblaRomanizationTable(iRomanizationTable%).V2RUppercaseFirstCharacterInSubfield, sTag$ + "/" + Mid(sOut$, lPtr + 1, 1)) > 0 Then
+                                        sOut$ = Mid(sOut$, 1, lPtr + 1) + LocalMarcRecordObject.UCaseFirstWord(Mid(sOut$, lPtr + 2))
+                                    End If
+                                End If
+                            Next ' lptr
+                        ElseIf Len(sSubfieldCode$) > 0 Then
+                            If InStr(gblaRomanizationTable(iRomanizationTable%).V2RUppercaseFirstCharacterInSubfield, sTag$ + "/" + sSubfieldCode$) > 0 Then
+                                sOut$ = LocalMarcRecordObject.UCaseFirstWord(sOut$)
+                            End If
+                        End If
+                    End If
+                End If
+        End Select
+
+    End If
+    
+    ReRomanizeText = LocalMarcRecordObject.RemoveRepeatedCharacters(sOut$, " ")
+    
+    'DumpRomanizationTables
+    
+End Function
+
+Public Sub LoadOneRomanizationTable(ByVal sFileNameIncludingPath$, ByRef LocalMarcRecordObject As Utf8MarcRecordClass, ByRef LocalCharacterObject As Utf8CharClass, ByRef sDefaultFieldsIncluded$, Optional ByRef ProgressBarCtrl As Control = Nothing)
+
+    ' we're going to read the file line-by-line, even though it has the
+    '   general appearance of an INI file, because it may be more than
+    '   32K (for Chinese)
+    
+    Dim iIn%, iMode%, iElement%, iRc%, iRc2%, iRc3%
+    
+    Dim sRight$, sLeft$, sUpperCase$, sTruncation$, sOriginal$
+    
+    Dim bLeft As Boolean, bRight As Boolean
+    
+    sTruncation$ = "%"
+    
+    iIn% = FreeFile
+    On Error GoTo LRFT_FileOpenError
+    Open sFileNameIncludingPath$ For Input As #iIn%
+    On Error GoTo 0
+    
+    ' if we get this far we must have *something*
+    gbliRomanizationTableLast% = gbliRomanizationTableLast% + 1
+    If gbliRomanizationTableLast% > gbliRomanizationTableMax% Then
+        gbliRomanizationTableMax% = gbliRomanizationTableMax% + 5
+        ReDim Preserve gblaRomanizationTable(0 To gbliRomanizationTableMax%)
+    End If
+    
+    With gblaRomanizationTable(gbliRomanizationTableLast%)
+        
+        ' save the file name, in case we need to add to it later
+        .FullFileName = sFileNameIncludingPath$
+        
+        ' by default, include everything 100 through 840
+        .R2VFieldsIncluded = sDefaultFieldsIncluded$
+        .V2RFieldsIncluded = sDefaultFieldsIncluded$
+        ' these subfields are always excluded
+        .R2VSubfieldsAlwaysExcluded = "uvxy0123456789"
+        .V2RSubfieldsAlwaysExcluded = "uvxy0123456789"
+        ' there is no additional tag-based exclusion of subfields
+        .R2VOtherSubfieldsExcludedByTag = ""
+        .V2ROtherSubfieldsExcludedByTag = ""
+        ' 20070703: added IncludeFormattingCharactersLcPattern; default False
+        .R2VIncludeFormattingCharactersLcPattern = False
+        ' set default script identification code
+        .R2VSubfield6Code = ""
+        ' 20100809 Bucknum added: VowelMarker
+        ' set default script vowel marker
+        .R2VVowelMarker = ""
+        
+        Set .Roman2Vernacular = CreateObject("Scripting.Dictionary")
+        Set .Vernacular2Roman = CreateObject("Scripting.Dictionary")
+        
+        .AllowDefineButton = False
+        .FontName = ""
+        
+        Do While Not EOF(iIn%)
+            Line Input #iIn%, sRight$
+
+            '20090322 added by Bucknum:
+            'monitor progress of romanization table load
+            If Not ProgressBarCtrl Is Nothing Then
+                DoEvents
+                'add 2 to the line input for line-feed characters
+                LoadRomanizationTablesProgress Len(sRight$) + 2, ProgressBarCtrl
+            End If
+            
+            If Len(sRight$) > 0 Then
+                If Mid(sRight$, 1, 1) <> "#" Then
+                    If Mid(sRight$, 1, 1) = "[" Then
+                        Select Case Trim(UCase(sRight$))
+                            Case "[GENERAL]"
+                                iMode% = 1
+                            Case "[ROMANTOSCRIPT]"
+                                iMode% = 2
+                            Case "[SCRIPTTOROMAN]"
+                                iMode% = 3
+                            Case Else
+                                If .NoRomanization Then ' 20070830 added
+                                    Exit Do
+                                End If
+                                iMode% = 4 ' we'll ignore all of this!
+                        End Select
+                        
+                    Else
+                    
+                        Select Case iMode%
+                        
+                            Case 1 ' general stanza: options and switches
+                                GetNextPiece sRight$, sLeft$, "="
+                                Select Case sLeft$
+                                    Case "Name"
+                                        .Name = sRight$
+                                    Case "FontName"
+                                        ' 20180928 added for font customization by language/script
+                                        '   for Swiss-type, proportionally-spaced, sans-serif fonts
+                                        .FontName = sRight$
+                                    Case "NoRomanization"
+                                        ' 20070830 added NoRomanization concept
+                                        .NoRomanization = LocalMarcRecordObject.IsTrue(sRight$)
+                                    Case "DoNotUse880Field"
+                                        .DoNotUse880Field = LocalMarcRecordObject.IsTrue(sRight$)
+                                    Case "AllowCaseVariation"
+                                        .AllowCaseVariation = LocalMarcRecordObject.IsTrue(sRight$)
+                                    Case "ApostropheCharacters"
+                                        'Debug.Print "RA 2"
+                                        .ApostropheCharacters = RomanizeConvertText(sRight$, LocalMarcRecordObject, LocalCharacterObject)
+                                        If Len(.ApostropheCharacters) > 0 Then
+                                            .ApostropheCharactersPresent = True
+                                        End If
+                                    Case "AllowDefineButton"
+                                        .AllowDefineButton = LocalMarcRecordObject.IsTrue(sRight$)
+                                    Case "BySyllables"
+                                        .BySyllables = LocalMarcRecordObject.IsTrue(sRight$)
+                                    Case "Truncation"
+                                        sTruncation$ = sRight$
+                                End Select
+                                
+                            Case 2 ' roman to vernacular script (including Wade-Giles to Pinyin)
+                            
+                                If InStr(sRight$, "=") > 0 Then
+                                    GetNextPiece sRight$, sLeft$, "="
+                                    Select Case sLeft$
+                                        Case "FieldsIncluded"
+                                            .R2VFieldsIncluded = sRight$
+                                            GoTo LORT_NextLine
+                                        Case "IncludeFormattingCharactersLcPattern"
+                                            ' 20070703: added
+                                            .R2VIncludeFormattingCharactersLcPattern = True
+                                            GoTo LORT_NextLine
+                                        Case "CreateEmpty880s"
+                                            .R2VCreateEmpty880s = True
+                                            GoTo LORT_NextLine
+                                        Case "Subfield6Code"
+                                            .R2VSubfield6Code = sRight$
+                                            GoTo LORT_NextLine
+                                        Case "SubfieldsAlwaysExcluded"
+                                            .R2VSubfieldsAlwaysExcluded = sRight$
+                                            GoTo LORT_NextLine
+                                        Case "OtherSubfieldsExcludedByTag"
+                                            .R2VOtherSubfieldsExcludedByTag = sRight$
+                                            GoTo LORT_NextLine
+                                        Case "VowelMarker"
+                                            ' 20100809 Bucknum added:
+                                            .R2VVowelMarker = sRight$
+                                            GoTo LORT_NextLine
+                                    End Select
+LORT_RTV_ContinueWithDividedLine:   ' NOTE label in left margin
+                                    bLeft = False
+                                    bRight = False
+                                    If Mid(sLeft$, 1, 1) = sTruncation$ Then
+                                        bLeft = True
+                                        sLeft$ = Mid(sLeft$, 2)
+                                    End If
+                                    If Right(sLeft$, 1) = sTruncation$ Then
+                                        bRight = True
+                                        sLeft$ = Mid(sLeft$, 1, Len(sLeft$) - 1)
+                                    End If
+                                    'Debug.Print "RA 3"
+                                    sRight$ = RomanizeConvertText(sRight$, LocalMarcRecordObject, LocalCharacterObject)
+                                    sLeft$ = RomanizeConvertText(sLeft$, LocalMarcRecordObject, LocalCharacterObject)
+                                    'If Mid(sLeft$, 1, 1) = "v" Then
+                                    '    Debug.Print "After 3: >" + sLeft$ + "< >" + sRight$ + "<"
+                                    'End If
+                                    
+                                    iRc% = InStr(sRight$, "/")
+                                    If iRc% > 0 Then
+                                        sUpperCase$ = Mid(sRight$, 1, iRc% - 1)
+                                        sRight$ = Mid(sRight$, iRc% + 1)
+                                    Else
+                                        sUpperCase$ = ""
+                                    End If
+                                    LocalCharacterObject.Utf8Char = sLeft$ ' isolating the first character
+                                    If .Roman2Vernacular.Exists(LocalCharacterObject.Utf8Char) Then
+                                        iElement% = .Roman2Vernacular.item(LocalCharacterObject.Utf8Char)
+                                    Else
+                                        .RomanLast = .RomanLast + 1
+                                        If .RomanLast > .RomanMax Then
+                                            .RomanMax = .RomanMax + 10
+                                            ReDim Preserve .Roman(0 To .RomanMax)
+                                        End If
+                                        iElement% = .RomanLast
+                                        .Roman2Vernacular.Add LocalCharacterObject.Utf8Char, iElement%
+                                    End If
+                                    .Roman(iElement%).DetailLast = .Roman(iElement%).DetailLast + 1
+                                    If .Roman(iElement%).DetailLast > .Roman(iElement%).DetailMax Then
+                                        .Roman(iElement%).DetailMax = .Roman(iElement%).DetailMax + 5
+                                        ReDim Preserve .Roman(iElement%).Detail(0 To .Roman(iElement%).DetailMax)
+                                    End If
+                                    If .AllowCaseVariation Then
+                                        .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).FullString = LocalMarcRecordObject.SafeLCase(sLeft$)
+                                        'Debug.Print "Before and after: >" + sLeft$ + "< >" + .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).FullString + "<"
+                                    Else
+                                        .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).FullString = sLeft$
+                                    End If
+                                    .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).FullStringLengthInCharacters = LocalMarcRecordObject.SafeLen(sLeft$)
+                                    .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).FullStringLengthInBytes = Len(sLeft$)
+                                    .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).Equivalent = sRight$
+                                    .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).EquivalentUpperCasePresent = False
+                                    If Len(sUpperCase$) > 0 Then
+                                        .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).EquivalentUpperCase = sUpperCase$
+                                        .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).EquivalentUpperCasePresent = True
+                                    End If
+                                    If bLeft Then
+                                        If bRight Then
+                                            .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).MedialOnly = True
+                                        Else
+                                            .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).TerminalOnly = True
+                                        End If
+                                    ElseIf bRight Then
+                                        .Roman(iElement%).Detail(.Roman(iElement%).DetailLast).InitialOnly = True
+                                    End If
+                                
+                                ElseIf InStr(sRight$, vbTab) > 0 Then
+                                                        
+                                    GetNextPiece sRight$, sLeft$, vbTab
+                                    GoTo LORT_RTV_ContinueWithDividedLine
+                                                                                        
+                                End If
+                                
+                            Case 3 ' vernacular script to roman
+                                
+                                If InStr(sRight$, "=") > 0 Then
+                                
+                                    GetNextPiece sRight$, sLeft$, "="
+
+                                    Select Case sLeft$
+                                        Case "CreateEmptyFields" ' added 20070830
+                                            .V2RCreateEmptyFields = True
+                                            GoTo LORT_NextLine
+                                        Case "FieldsIncluded"
+                                            .V2RFieldsIncluded = sRight$
+                                            GoTo LORT_NextLine
+                                        Case "SubfieldsAlwaysExcluded"
+                                            .V2RSubfieldsAlwaysExcluded = sRight$
+                                            GoTo LORT_NextLine
+                                        Case "OtherSubfieldsExcludedByTag"
+                                            .V2ROtherSubfieldsExcludedByTag = sRight$
+                                            GoTo LORT_NextLine
+                                        Case "UppercaseFirstCharacterInSubfield"
+                                            .V2RUppercaseFirstCharacterInSubfield = sRight$
+                                            GoTo LORT_NextLine
+                                        Case "PersonalNameHandling"
+                                            .V2RPersonalNameUppercase = LocalMarcRecordObject.IsTrue(sRight$)
+                                            GoTo LORT_NextLine
+                                    End Select
+LORT_VTR_ContinueWithDividedLine:
+                                    bLeft = False
+                                    bRight = False
+                                    If Mid(sLeft$, 1, 1) = sTruncation$ Then
+                                        bLeft = True
+                                        sLeft$ = Mid(sLeft$, 2)
+                                    End If
+                                    If Right(sLeft$, 1) = sTruncation$ Then
+                                        bRight = True
+                                        sLeft$ = Mid(sLeft$, 1, Len(sLeft$) - 1)
+                                    End If
+                                    'Debug.Print "RA 4"
+                                    sRight$ = RomanizeConvertText(sRight$, LocalMarcRecordObject, LocalCharacterObject)
+                                    sLeft$ = RomanizeConvertText(sLeft$, LocalMarcRecordObject, LocalCharacterObject)
+                                    iRc% = InStr(sRight$, "/")
+                                    If iRc% > 0 Then
+                                        sUpperCase$ = Mid(sRight$, 1, iRc% - 1)
+                                        sRight$ = Mid(sRight$, iRc% + 1)
+                                    Else
+                                        sUpperCase$ = ""
+                                    End If
+                                    LocalCharacterObject.Utf8Char = sLeft$ ' isolating the first character
+                                                                        
+                                    If .Vernacular2Roman.Exists(LocalCharacterObject.Utf8Char) Then
+                                        iElement% = .Vernacular2Roman.item(LocalCharacterObject.Utf8Char)
+                                    Else
+                                        .VernacularLast = .VernacularLast + 1
+                                        If .VernacularLast > .VernacularMax Then
+                                            .VernacularMax = .VernacularMax + 10
+                                            ReDim Preserve .Vernacular(0 To .VernacularMax)
+                                        End If
+                                        iElement% = .VernacularLast
+                                        .Vernacular2Roman.Add LocalCharacterObject.Utf8Char, iElement%
+                                    End If
+                                    .Vernacular(iElement%).DetailLast = .Vernacular(iElement%).DetailLast + 1
+                                    If .Vernacular(iElement%).DetailLast > .Vernacular(iElement%).DetailMax Then
+                                        .Vernacular(iElement%).DetailMax = .Vernacular(iElement%).DetailMax + 5
+                                        ReDim Preserve .Vernacular(iElement%).Detail(0 To .Vernacular(iElement%).DetailMax)
+                                    End If
+                                    .Vernacular(iElement%).Detail(.Vernacular(iElement%).DetailLast).FullString = sLeft$
+                                    .Vernacular(iElement%).Detail(.Vernacular(iElement%).DetailLast).FullStringLengthInCharacters = LocalMarcRecordObject.SafeLen(sLeft$)
+                                    .Vernacular(iElement%).Detail(.Vernacular(iElement%).DetailLast).FullStringLengthInBytes = Len(sLeft$)
+                                    .Vernacular(iElement%).Detail(.Vernacular(iElement%).DetailLast).Equivalent = sRight$
+                                    .Vernacular(iElement%).Detail(.Vernacular(iElement%).DetailLast).EquivalentUpperCasePresent = False
+                                    If bLeft Then
+                                        If bRight Then
+                                            .Vernacular(iElement%).Detail(.Vernacular(iElement%).DetailLast).MedialOnly = True
+                                        Else
+                                            .Vernacular(iElement%).Detail(.Vernacular(iElement%).DetailLast).TerminalOnly = True
+                                        End If
+                                    ElseIf bRight Then
+                                        .Vernacular(iElement%).Detail(.Vernacular(iElement%).DetailLast).InitialOnly = True
+                                    End If
+                            
+                                ' main condition is: contains equals sign?
+                                ElseIf InStr(sRight$, vbTab) > 0 Then
+                                    GetNextPiece sRight$, sLeft$, vbTab
+                                    GoTo LORT_VTR_ContinueWithDividedLine
+                                End If
+                        
+                        End Select
+                    End If
+                End If
+            End If
+LORT_NextLine:
+        Loop
+        If Len(.Name) = 0 Then
+            .Name = "Unknown script #" + Trim(str(gbliRomanizationTableLast%))
+        End If
+        
+
+
+    End With
+    
+    Close #iIn%
+    
+LRFT_FileOpenErrorresume:
+
+    Exit Sub
+    
+LRFT_FileOpenError:
+
+    Resume LRFT_FileOpenErrorresume
+    
+End Sub
+
+Public Function RomanizeConvertText(ByVal sIn$, ByRef LocalMarcRecordObject As Utf8MarcRecordClass, ByRef LocalCharacterObject As Utf8CharClass) As String
+
+    ' convert "&H notations to the equivalent, leaving other stuff as you find it
+    Dim lPtr As Long
+    
+    Dim sLeader$, sOriginal$
+    
+    Dim bShow As Boolean
+    
+    
+'    If InStr(sIn$, "U+") > 0 Then
+'        bShow = True
+'        sOriginal$ = sIn$
+'    End If
+
+    sIn$ = LocalMarcRecordObject.ReplaceCharacters(sIn$, "_", " ")
+    
+    sLeader$ = "&H"
+    
+    Do
+        lPtr = InStr(sIn$, sLeader$)
+        Do While lPtr > 0
+            LocalCharacterObject.UcsHex = Mid(sIn$, lPtr + 2, 4)
+            sIn$ = LocalMarcRecordObject.SafeStuff(sIn$, lPtr, 6, LocalCharacterObject.Utf8Char)
+            lPtr = InStr(sIn$, sLeader$)
+        Loop
+        Select Case sLeader$
+            Case "&H"
+                sLeader$ = "U+"
+            Case "U+"
+                sLeader$ = "&x"
+            Case "&x"
+                sLeader$ = "&X"
+            Case "&X"
+                sLeader$ = "&h"
+            Case "&h"
+                Exit Do
+        End Select
+    Loop
+    
+'    If bShow Then
+'        Debug.Print "RCT >" + sOriginal$ + "< >" + sIn$ + "<"
+'    End If
+    
+    RomanizeConvertText = sIn$
+    
+End Function
+
+Public Sub LoadRomanizationTables(ByVal sConfigurationFilePath$, ByRef LocalMarcRecordObject As Utf8MarcRecordClass, ByRef LocalCharacterObject As Utf8CharClass, Optional ByRef ProgressBarCtrl As Control = Nothing)
+
+    Dim sMasterFile$, sFile$, sDefaultFieldsIncluded$
+    
+    Dim iCtr%
+    
+'    Static bLoaded As Boolean
+    
+    Dim bDebug As Boolean
+    
+    ' 20090322 changed by Bucknum:
+    ' removed bLoaded to allow reloading tables
+'    If bLoaded Then
+'        Exit Sub
+'    End If
+    
+    'prvsRightToLeftMarker$ , prvsLeftToRightMarker$
+    
+    'prvsRightToLeftMarker$ = LocalMarcRecordObject.MarcRightToLeftMarker
+    'prvsLeftToRightMarker$ = LocalMarcRecordObject.MarcLeftToRightMarker
+    
+    For iCtr% = 100 To 840
+        sDefaultFieldsIncluded$ = sDefaultFieldsIncluded$ + " " + Trim(str(iCtr%))
+    Next ' irc%
+    
+    sMasterFile$ = sConfigurationFilePath$ + "RomanizationMaster.cfg"
+    
+    bDebug = LocalMarcRecordObject.IsTrue(ReadIniFile(sMasterFile$, "Files", "Debug", "False", 15))
+        
+    iCtr% = 1
+    Do
+        sFile$ = ReadIniFileOrNothing(sMasterFile$, "Files", Trim(str(iCtr%)), 250)
+        If Len(sFile$) = 0 Then
+            If bDebug Then
+                MsgBox "For " + Trim(str(iCtr%)) + " read: >" + sFile$ + "<"
+            End If
+            Exit Do
+        End If
+        If InStr(sFile$, "\") = 0 Then
+            If LenB(Dir$(sConfigurationFilePath$ + sFile$)) > 0 And gblaRomanizationScript(iCtr%).LoadScript Then
+                LoadOneRomanizationTable sConfigurationFilePath$ + sFile$, LocalMarcRecordObject, LocalCharacterObject, sDefaultFieldsIncluded$, ProgressBarCtrl
+                If bDebug Then
+                    MsgBox "For " + Trim(str(iCtr%)) + " read: >" + sConfigurationFilePath$ + sFile$ + "< vernacular entries " + str(gblaRomanizationTable(gbliRomanizationTableLast%).VernacularLast) + " roman entries " + str(gblaRomanizationTable(gbliRomanizationTableLast%).RomanLast)
+                End If
+            End If
+        Else
+            If LenB(Dir$(sFile$)) > 0 And gblaRomanizationScript(iCtr%).LoadScript Then
+                LoadOneRomanizationTable sFile$, LocalMarcRecordObject, LocalCharacterObject, sDefaultFieldsIncluded$, ProgressBarCtrl
+                If bDebug Then
+                    MsgBox "For " + Trim(str(iCtr%)) + " read: >" + sFile$ + "< vernacular entries " + str(gblaRomanizationTable(gbliRomanizationTableLast%).VernacularLast) + " roman entries " + str(gblaRomanizationTable(gbliRomanizationTableLast%).RomanLast)
+                End If
+            End If
+        End If
+        iCtr% = iCtr% + 1
+    Loop
+    
+'    bLoaded = True
+    
+End Sub
+
+Public Sub DumpRomanizationTables()
+
+    Dim iCtr%, iCtr2%, iCtr3%
+    
+    For iCtr% = 1 To gbliRomanizationTableLast%
+        With gblaRomanizationTable(iCtr%)
+            Debug.Print "Name: " + .Name
+            Debug.Print "Roman to vernacular"
+            For iCtr2% = 1 To .RomanLast
+                With .Roman(iCtr2%)
+                    For iCtr3% = 1 To .DetailLast
+                        Debug.Print vbTab + .Detail(iCtr3%).FullString + vbTab + .Detail(iCtr3%).Equivalent
+                    Next ' ictr3%
+                End With
+            Next ' ictr2%
+            Debug.Print "Vernacular to roman"
+            For iCtr2% = 1 To .VernacularLast
+                With .Vernacular(iCtr2%)
+                    For iCtr3% = 1 To .DetailLast
+                        Debug.Print vbTab + .Detail(iCtr3%).FullString + vbTab + .Detail(iCtr3%).Equivalent
+                    Next ' ictr3%
+                End With
+            Next ' ictr2%
+        End With
+    Next ' ictr%
+    
+End Sub
+
+Public Sub LoadListOfScriptsIntoControl(ByRef c As Control)
+
+    Dim iCtr%
+
+    With c
+        If c.style = vbListBoxCheckbox Then
+            c.Clear
+            For iCtr% = 1 To gbliRomanizationScriptLast%
+                .AddItem gblaRomanizationScript(iCtr%).Name
+                .Selected(iCtr% - 1) = gblaRomanizationScript(iCtr%).LoadScript
+            Next ' ictr%
+        Else
+            If .ListCount = 0 Then
+                For iCtr% = 1 To gbliRomanizationTableLast%
+                    .AddItem gblaRomanizationTable(iCtr%).Name
+                Next ' ictr%
+                If .ListCount > 0 Then
+                    .ListIndex = 0
+                End If
+            End If
+        End If
+    End With
+
+End Sub
+
+Private Function ReRomanizeTextDetails(ByVal sText$, ByRef oRomanizationTable As Object, ByRef RomanizationTable() As ROMANIZATIONDETAILARRAY, ByRef LocalMarcRecordObject As Utf8MarcRecordClass, ByRef LocalMarcCharacter As Utf8CharClass, ByVal bRoman2Vernacular As Boolean, ByVal iRomanizationTable%)
+
+    Dim iLen%, iLengthBeforeApostropheSubstitution%
+    
+    Dim lPtr As Long, lPtr2 As Long, lMember As Long, lCtr As Long, lEnd As Long
+    
+    Dim sOut$, sPreviousCharacter$, sSyllable$, sChar1$, sChar2$, sOriginalSyllable$
+    
+    Dim bFound As Boolean, bFirstCharacter As Boolean, bFirstCharacterIsUppercase As Boolean
+    Dim bApostrophes As Boolean, bWholeThingIsUppercase As Boolean, bChanged As Boolean
+    Dim bAllowCaseVariation
+    
+    ' we have to manipulate pointers directly, ourselves, because
+    '   of varying character length
+    lPtr = 1
+    lEnd = Len(sText$)
+        
+    bApostrophes = gblaRomanizationTable(iRomanizationTable%).ApostropheCharactersPresent
+    
+
+    
+    If gblaRomanizationTable(iRomanizationTable%).AllowCaseVariation Then
+        bAllowCaseVariation = True
+    End If
+    
+    If Not gblaRomanizationTable(iRomanizationTable%).BySyllables Then
+    
+        ' we're working by characters
+        bFirstCharacter = True
+        Do While lPtr <= lEnd
+            bFound = False
+            If lPtr > 1 Then
+                sPreviousCharacter$ = LocalMarcCharacter.Utf8Char
+                If sPreviousCharacter$ = " " Then
+                    bFirstCharacterIsUppercase = False
+                End If
+            End If
+            LocalMarcCharacter.Utf8Char = Mid(sText$, lPtr)
+            ' 20061129: if we're going to be ignoring case, then
+            '   convert to lowercase
+            If bAllowCaseVariation Then
+                If LocalMarcCharacter.Utf8CharCategory = "Lu" Then
+                    LocalMarcCharacter.Utf8Char = LocalMarcRecordObject.SafeLCase(LocalMarcCharacter.Utf8Char)
+                    If bFirstCharacter Or sPreviousCharacter$ = " " Then
+                        bFirstCharacterIsUppercase = True
+                    End If
+                End If
+            End If
+            If InStr("Lu Ll Lo", LocalMarcCharacter.Utf8CharCategory) > 0 Then
+                bFirstCharacter = False
+            End If
+
+            If LocalMarcCharacter.Utf8Char = LocalMarcCharacter.MarcDelimiter Then
+                sOut$ = sOut$ + Mid(sText$, lPtr, 2) ' delimiter and subfield code
+                lPtr = lPtr + 1 ' we'll add one more at the bottom of the loop as per usual
+                iLen% = 1 ' make sure we only skip one more!
+            Else ' not at a delimiter: must be some character worthy of inspection
+                iLen% = LocalMarcCharacter.Utf8CharOctets
+                If oRomanizationTable.Exists(LocalMarcCharacter.Utf8Char) Then
+                    lMember = oRomanizationTable.item(LocalMarcCharacter.Utf8Char)
+
+                    With RomanizationTable(lMember)
+                        For lCtr = 1 To .DetailLast
+
+                            If .Detail(lCtr).InitialOnly Then
+                                ' 20100103 added by Bucknum:
+                                '  we are expecting more character(s) to follow, so the
+                                '  following 2 statements check for end of the word
+                                If lPtr + .Detail(lCtr).FullStringLengthInBytes >= lEnd Then
+                                    ' this is the end of the word; so no dice
+                                    GoTo RRTD_NextDetail
+                                ElseIf InStr(" -.?,;:!""])" + LocalMarcRecordObject.MarcDelimiter, Mid(sText$, lPtr + .Detail(lCtr).FullStringLengthInBytes, 1)) > 0 Then
+                                    ' this is also the end of the word; so no dice
+                                    GoTo RRTD_NextDetail
+                                ElseIf lPtr = 1 Then
+                                    ' this is OK: first character in the string is taken
+                                    '   to be start of a word
+                                    ' 20180801: Bucknum added left bracket and parenthesis
+                                ElseIf InStr(" -""[(", Mid(sText$, lPtr - 1, 1)) > 0 Then
+                                    ' this is OK, too: previous character is a word-breaker
+                                    '   (following space, hyphen, quote, bracket or parenthesis), so current
+                                    '   character is the first in this word
+                                ElseIf lPtr > 2 Then
+                                    If Mid(sText$, lPtr - 2, 1) = LocalMarcRecordObject.MarcDelimiter Then
+                                        ' this is OK, too: character is first in its subfield
+                                    Else
+                                        GoTo RRTD_NextDetail
+                                    End If
+                                Else
+                                    ' not at the beginning of a word
+                                    GoTo RRTD_NextDetail
+                                End If
+                            ElseIf .Detail(lCtr).TerminalOnly Then
+                                ' 20070731: we were using iLen% here as the length; but we should be using
+                                '   the length of the character(s) in the defined terminal-only string
+                                '   (for example, the current character may be "o" but if we're looking for
+                                '   terminal "ot" then we need to compare and skip over 2 characters, not 1)
+                                ' fortunately, we already have FullStringLengthInBytes giving the length of
+                                '   the string to be found in the original record
+
+                                If lPtr + .Detail(lCtr).FullStringLengthInBytes > lEnd Then
+                                    ' this is OK: must be last character in the string
+                                ElseIf InStr(" -.?,;:!""])" + LocalMarcRecordObject.MarcDelimiter, Mid(sText$, lPtr + .Detail(lCtr).FullStringLengthInBytes, 1)) > 0 Then
+                                    ' this is OK, too: next character is a word-breaker,
+                                    '   so current character is the last in this word
+                                Else
+                                    ' not at the end of a word
+                                    GoTo RRTD_NextDetail
+                                End If
+                                ' if we get here then we're at the end of the word and so ready
+                                '   to test the characters
+                            ElseIf .Detail(lCtr).MedialOnly Then
+                                ' can not be either the beginning or the ending of a word
+                                ' we'll simply reverse all of the above tests; in this case the
+                                '   leftovers are the things that aren't either beginning or
+                                '   end--they must be medial
+                                If lPtr = 1 Then
+                                    ' initial: so no dice
+                                    GoTo RRTD_NextDetail
+                                ElseIf InStr(" -""[(", Mid(sText$, lPtr - 1, 1)) > 0 Then
+                                    ' initial (following space, hyphen, quote, bracket or parenthesis): so no dice
+                                    ' 20180801: Bucknum added left bracket and parenthesis
+                                    GoTo RRTD_NextDetail
+                                ElseIf lPtr > 2 Then
+                                    If Mid(sText$, lPtr - 2, 1) = LocalMarcRecordObject.MarcDelimiter Then
+                                        ' beginning of a subfield: so no dice
+                                        GoTo RRTD_NextDetail
+                                    End If
+                                ' 20070731: see comment above (at TerminalOnly) regarding the
+                                '   length to be used in the following 2 statements
+                                ElseIf lPtr + .Detail(lCtr).FullStringLengthInBytes >= lEnd Then
+                                    ' this is the end of the word; so no dice
+                                    GoTo RRTD_NextDetail
+                                ElseIf InStr(" -.?,;:!""])" + LocalMarcRecordObject.MarcDelimiter, Mid(sText$, lPtr + .Detail(lCtr).FullStringLengthInBytes, 1)) > 0 Then
+                                    ' this is also the end of the word; so no dice
+                                    GoTo RRTD_NextDetail
+                                End If
+                                ' if we get here, then we're somewhere within a word and ready to
+                                '   test the characters
+                            End If
+                            ' if we get here, either we don't care what position the character
+                            '   bears within its word, or whatever conditions were specified have
+                            '   been met
+                            If bRoman2Vernacular Then
+                                If LocalMarcCharacter.Utf8CharCategory = "Lu" Then
+
+                                    If Not bApostrophes Then
+                                        If Mid(sText, lPtr, .Detail(lCtr).FullStringLengthInBytes) = .Detail(lCtr).FullString Then
+                                            bFound = True
+                                            If .Detail(lCtr).EquivalentUpperCasePresent Then
+                                                If Len(sPreviousCharacter$) = 0 Then
+                                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                Else
+                                                    LocalMarcCharacter.Utf8Char = sPreviousCharacter$
+                                                    If LocalMarcCharacter.Utf8CharCategory = "Lu" Then
+                                                        sOut$ = sOut$ + .Detail(lCtr).EquivalentUpperCase
+                                                    Else
+                                                        sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                    End If
+                                                End If
+                                                bChanged = True
+                                                iLen% = .Detail(lCtr).FullStringLengthInBytes
+                                            Else
+                                                If bFirstCharacterIsUppercase Then
+                                                    sOut$ = sOut$ + LocalMarcRecordObject.UCaseFirstWord(.Detail(lCtr).Equivalent)
+                                                    bFirstCharacterIsUppercase = False
+                                                Else
+                                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                End If
+                                                bChanged = True
+                                                iLen% = .Detail(lCtr).FullStringLengthInBytes
+                                            End If
+                                            Exit For
+                                        End If
+                                    Else ' apostrophes were defined
+
+                                        If ReRomanizeTextDetailsReplaceApostrophes(LocalMarcRecordObject.SafeUCase(LocalMarcRecordObject.SafeMid(sText, lPtr, .Detail(lCtr).FullStringLengthInCharacters)), iRomanizationTable%, LocalMarcCharacter, iLengthBeforeApostropheSubstitution%) = .Detail(lCtr).FullString Then
+
+                                            bFound = True
+                                            If .Detail(lCtr).EquivalentUpperCasePresent Then
+                                                If Len(sPreviousCharacter$) = 0 Then
+                                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                Else
+                                                    LocalMarcCharacter.Utf8Char = sPreviousCharacter$
+                                                    If LocalMarcCharacter.Utf8CharCategory = "Lu" Then
+                                                        sOut$ = sOut$ + .Detail(lCtr).EquivalentUpperCase
+                                                    Else
+                                                        sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                    End If
+                                                End If
+                                                bChanged = True
+                                                iLen% = iLengthBeforeApostropheSubstitution% '.Detail(lCtr).FullStringLengthInCharacters
+                                            Else
+                                                If bFirstCharacterIsUppercase Then
+                                                    sOut$ = sOut$ + LocalMarcRecordObject.UCaseFirstWord(.Detail(lCtr).Equivalent)
+                                                    bFirstCharacterIsUppercase = False
+                                                Else
+                                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                End If
+                                                bChanged = True
+                                                iLen% = iLengthBeforeApostropheSubstitution% '.Detail(lCtr).FullStringLengthInCharacters
+                                            End If
+                                            Exit For
+                                        End If
+                                    End If
+                                Else ' category is not letter/uppercase
+
+                                    If Not bApostrophes Then
+                                        If Mid(sText, lPtr, .Detail(lCtr).FullStringLengthInBytes) = .Detail(lCtr).FullString Or (bAllowCaseVariation And LCase(Mid(sText, lPtr, .Detail(lCtr).FullStringLengthInBytes)) = .Detail(lCtr).FullString) Then
+                                        'If Mid(sText, lPtr, .Detail(lCtr).FullStringLengthInBytes) = .Detail(lCtr).FullString Then
+                                            bFound = True
+                                            If .Detail(lCtr).EquivalentUpperCasePresent Then
+                                                If Len(sPreviousCharacter$) = 0 Then
+                                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                Else
+                                                    LocalMarcCharacter.Utf8Char = sPreviousCharacter$
+                                                    'Debug.Print "Previous " + sPreviousCharacter$ + " category " + LocalMarcCharacter.Utf8CharCategory
+                                                    If LocalMarcCharacter.Utf8CharCategory = "Lu" Then
+                                                        sOut$ = sOut$ + .Detail(lCtr).EquivalentUpperCase
+                                                    Else
+                                                        sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                    End If
+                                                End If
+                                                bChanged = True
+                                                iLen% = .Detail(lCtr).FullStringLengthInBytes
+                                            Else
+                                                If bFirstCharacterIsUppercase Then
+                                                    sOut$ = sOut$ + LocalMarcRecordObject.UCaseFirstWord(.Detail(lCtr).Equivalent)
+                                                    bFirstCharacterIsUppercase = False
+                                                Else
+                                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                End If
+                                                bChanged = True
+                                                iLen% = .Detail(lCtr).FullStringLengthInBytes
+                                            End If
+                                            Exit For
+                                        End If
+                                    Else ' apostrophes are defined
+
+                                        If ReRomanizeTextDetailsReplaceApostrophes(LocalMarcRecordObject.SafeLCase(LocalMarcRecordObject.SafeMid(sText, lPtr, .Detail(lCtr).FullStringLengthInCharacters)), iRomanizationTable%, LocalMarcCharacter, iLengthBeforeApostropheSubstitution%) = .Detail(lCtr).FullString Then
+                                            bFound = True
+
+                                            If .Detail(lCtr).EquivalentUpperCasePresent Then
+                                                If Len(sPreviousCharacter$) = 0 Then
+                                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                Else
+                                                    LocalMarcCharacter.Utf8Char = sPreviousCharacter$
+                                                    'Debug.Print "Previous " + sPreviousCharacter$ + " category " + LocalMarcCharacter.Utf8CharCategory
+                                                    If LocalMarcCharacter.Utf8CharCategory = "Lu" Then
+                                                        sOut$ = sOut$ + .Detail(lCtr).EquivalentUpperCase
+                                                    Else
+                                                        sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                    End If
+                                                End If
+                                                iLen% = iLengthBeforeApostropheSubstitution% '.Detail(lCtr).FullStringLengthInCharacters
+                                            Else
+                                                If bFirstCharacterIsUppercase Then
+                                                    sOut$ = sOut$ + LocalMarcRecordObject.UCaseFirstWord(.Detail(lCtr).Equivalent)
+                                                    bFirstCharacterIsUppercase = False
+                                                Else
+                                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                                End If
+                                                iLen% = iLengthBeforeApostropheSubstitution% ' .Detail(lCtr).FullStringLengthInCharacters
+                                            End If
+                                            Exit For
+                                        End If
+                                    End If
+                                End If
+                            Else ' vernacular to roman
+                                'Debug.Print "Considering " + str(.Detail(lCtr).FullStringLengthInBytes) + "< and >" + .Detail(lCtr).FullString + "<"
+                                If Mid(sText, lPtr, .Detail(lCtr).FullStringLengthInBytes) = .Detail(lCtr).FullString Then
+                                    bFound = True
+                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+
+                                    iLen% = .Detail(lCtr).FullStringLengthInBytes
+                                    If Right(sOut$, 1) = " " Then
+                                        lPtr2 = lPtr + iLen%
+                                        If lPtr2 <= lEnd Then
+                                            LocalMarcCharacter.Utf8Char = Mid(sText$, lPtr2)
+                                            If Mid(LocalMarcCharacter.Utf8CharCategory, 1, 1) = "P" Then
+                                                sOut$ = RTrim(sOut$)
+                                            End If
+                                        End If
+                                    End If
+                                    Exit For
+                                End If
+                            End If
+RRTD_NextDetail:            ' NOTE label in left margin
+                        Next ' lctr
+                    End With
+                Else
+
+                    bFound = False
+                End If
+                If Not bFound Then
+                    sOut$ = sOut$ + LocalMarcCharacter.Utf8Char
+                End If
+                'Debug.Print "Disposition: " + str(bFound) + " >" + LocalMarcCharacter.Utf8Char + "< >" + sOut$ + "<"
+            End If
+            lPtr = lPtr + iLen%
+            
+        Loop
+
+        'Debug.Print "LC PATTERN? " + str(gblaRomanizationTable(iRomanizationTable%).R2VIncludeFormattingCharactersLcPattern) + " " + str(bChanged)
+        ' 20070703: it seems simplest to throw this on at the end
+        ' LC wants a RTL marker before and after each delimiter,
+        '   EXCEPT immediately following the $6 marker itself
+        ' note that this can ONLY apply to things done character-by-character; doesn't apply
+        '   to "by syllables" (I think!)
+        If gblaRomanizationTable(iRomanizationTable%).R2VIncludeFormattingCharactersLcPattern And bChanged Then
+            For lPtr = Len(sOut$) - 1 To 1 Step -1
+                If Mid(sOut$, lPtr, 1) = LocalMarcRecordObject.MarcDelimiter Then
+                    lPtr2 = InStr(Mid(sOut$, lPtr + 1), LocalMarcRecordObject.MarcDelimiter)
+                    'Debug.Print "At delim: " + str(lPtr) + " " + str(lPtr2) + " >" + sOut$ + "< marker >" + LocalMarcRecordObject.MarcRightToLeftMarker + "< " + str(Len(LocalMarcRecordObject.MarcRightToLeftMarker))
+                    If lPtr2 <> 0 Then
+                        sOut$ = LocalMarcRecordObject.SafeStuff(sOut$, lPtr + lPtr2, 0, LocalMarcRecordObject.MarcRightToLeftMarker)
+                    End If
+                    ' there should not be a $6 in the text!
+                    If Mid(sOut$, lPtr + 1, 1) <> "6" Then
+                        sOut$ = LocalMarcRecordObject.SafeStuff(sOut$, lPtr + 2, 0, LocalMarcRecordObject.MarcRightToLeftMarker)
+                    End If
+                    'Debug.Print "After:  >" + sOut$ + "<"
+                End If
+            Next ' lptr
+        End If
+        
+    Else ' we *are* proceeding by syllables
+            
+        ' move any troublesome lead characters to the output, so we end up pointed
+        '   to the first "real" character in the first syllable--as close as we can
+        '   determine it, anyway
+        ' we'll include the apostrophe here, because it's only *internal* ones that
+        '   we need to pay attention to
+        ' todo: this might be better if done via the character object, and with
+        '   character categories ...
+        bFirstCharacter = True
+        Do
+            Select Case Mid(sText$, lPtr, 1)
+                Case "-", " ", ".", ";", ":", "(", ")", "[", "]", "!", "?", "'", Chr(34)
+                    lPtr = lPtr + 1
+                Case LocalMarcRecordObject.MarcDelimiter
+                    lPtr = lPtr + 2
+                Case Else
+                    Exit Do
+            End Select
+            If lPtr > lEnd Then
+                Exit Do
+            End If
+        Loop
+        ' attach any skipped characters to the output
+        If lPtr > 1 Then
+            sOut$ = Mid(sText$, 1, lPtr - 1)
+        End If
+        
+        ' when we arrive here, lPtr points to the first character of real interest
+        
+        Do While lPtr <= lEnd
+            ' starting from the character pointed to by lPtr, which we will assume
+            '   to be the first character in a "syllable", find the end of the
+            '   next syllable
+            iLen% = 0
+            ' do NOT here break at a hyphen!
+            For lPtr2 = lPtr + 1 To lEnd
+                If InStr("- .;:)([]!?" + Chr(34) + LocalMarcRecordObject.MarcDelimiter, Mid(sText, lPtr2, 1)) > 0 Then
+                    iLen% = lPtr2 - lPtr
+                    Exit For
+                End If
+            Next ' lptr2
+            ' if we didn't find any more words, we assume that
+            '   we're at the end of the string altogether
+            If iLen% = 0 Then
+                iLen% = Len(Mid(sText$, lPtr))
+            End If
+            sSyllable$ = Mid(sText, lPtr, iLen%)
+            If Right(sSyllable$, 1) = "'" Then
+                iLen% = iLen% - 1
+                lPtr2 = lPtr2 - 1
+                sSyllable$ = Mid(sSyllable$, 1, Len(sSyllable$) - 1)
+            End If
+
+            sOriginalSyllable$ = sSyllable$
+            
+            ' in the next paragraph, we're determining whether the first character
+            '   is uppercase, or the whole thing is uppercase--we'll preserve
+            '   case in the finished string to the extent possible
+#If True Then
+            ' 20070109: paradigm changed (now much simpler); changed mostly because
+            '   the old one didn't work properly anyway
+            If sSyllable$ = LocalMarcRecordObject.SafeUCase(sSyllable$) Then
+                ' the only way this can happen is if it's all uppercase
+                bWholeThingIsUppercase = True
+                bFirstCharacterIsUppercase = False
+                If gblaRomanizationTable(iRomanizationTable%).AllowCaseVariation Then
+                    sSyllable$ = LocalMarcRecordObject.SafeLCase(sSyllable$)
+                End If
+            ElseIf sSyllable$ = LocalMarcRecordObject.SafeLCase(sSyllable$) Then
+                bWholeThingIsUppercase = False
+                bFirstCharacterIsUppercase = False
+            Else
+                ' there is some difference between the lowercase and uppercase versions:
+                '   for Wade-Giles, we *should* be able to assume that the difference
+                '   is on the first character
+                bWholeThingIsUppercase = False
+                bFirstCharacterIsUppercase = True
+                If gblaRomanizationTable(iRomanizationTable%).AllowCaseVariation Then
+                    sSyllable$ = LocalMarcRecordObject.SafeLCase(sSyllable$)
+                End If
+            End If
+            LocalMarcCharacter.Utf8Char = sSyllable$
+
+#Else
+            ' get the first character of this syllable
+            LocalMarcCharacter.Utf8Char = sSyllable$
+            If gblaRomanizationTable(iRomanizationTable%).AllowCaseVariation Then
+                If LocalMarcCharacter.Utf8CharCategory = "Lu" Then
+                    bFirstCharacterIsUppercase = True
+                    bWholeThingIsUppercase = True
+                    Do
+                        sSyllable$ = Mid(sSyllable$, LocalMarcCharacter.Utf8CharOctets + 1)
+                        If Len(sSyllable$) = 0 Then
+                            Exit Do
+                        End If
+                        'Debug.Print "Remaining syllable: >" + sSyllable$ + "<"
+                        LocalMarcCharacter.Utf8Char = sSyllable$
+                        'Debug.Print "Category: >" + LocalMarcCharacter.Utf8CharCategory + "<"
+                        If LocalMarcCharacter.Utf8CharCategory <> "Lu" Then
+                            bWholeThingIsUppercase = False
+                            Exit Do
+                        End If
+                    Loop
+                    ' re-get the whole syllable
+                    sSyllable$ = Mid(sText, lPtr, iLen%)
+                    LocalMarcCharacter.Utf8Char = sSyllable$
+                End If
+                ' in any case, because case variation is allowed, we'll
+                '   convert the syllable to lowercase
+                sSyllable$ = LocalMarcRecordObject.SafeLCase(sSyllable$)
+                LocalMarcCharacter.Utf8Char = sSyllable$
+            End If
+#End If ' alternative methods for determining casing of the existing syllable
+            
+            ' deal with things that look like apostrophes
+            If bApostrophes Then
+                sSyllable$ = ReRomanizeTextDetailsReplaceApostrophes(sSyllable$, iRomanizationTable%, LocalMarcCharacter, iLengthBeforeApostropheSubstitution%)
+            End If
+            
+            bFound = False
+            If oRomanizationTable.Exists(LocalMarcCharacter.Utf8Char) Then
+                lMember = oRomanizationTable.item(LocalMarcCharacter.Utf8Char)
+                With RomanizationTable(lMember)
+                    For lCtr = 1 To .DetailLast
+                        If bRoman2Vernacular Then
+                            If sSyllable$ = .Detail(lCtr).FullString Then
+                                bFound = True
+                                If bWholeThingIsUppercase Then
+                                    sOut$ = sOut$ + LocalMarcRecordObject.SafeUCase(.Detail(lCtr).Equivalent)
+                                    bFirstCharacterIsUppercase = False
+                                ElseIf bFirstCharacterIsUppercase Then
+                                    sOut$ = sOut$ + LocalMarcRecordObject.UCaseFirstWord(.Detail(lCtr).Equivalent)
+                                    bFirstCharacterIsUppercase = False
+                                Else
+                                    sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                End If
+                                Exit For
+                            End If
+                        Else ' vernacular to roman
+                            If sSyllable$ = .Detail(lCtr).FullString Then
+                                bFound = True
+                                sOut$ = sOut$ + .Detail(lCtr).Equivalent
+                                Exit For
+                            End If
+                        End If
+                    Next ' lctr
+                End With
+            Else
+
+                sSyllable$ = sOriginalSyllable$
+                bFound = False
+            End If
+            If Not bFound Then
+                sOut$ = sOut$ + sSyllable$
+            End If
+            
+            ' skip the syllable in input
+            lPtr = lPtr + iLen%
+            If lPtr > lEnd Then
+                ' no more input: all done
+                Exit Do
+            End If
+            ' move additional characters to the output string until
+            '   you hit the first that's not a "division" character
+            Do
+                Select Case Mid(sText$, lPtr, 1)
+                    Case "-", " ", ".", ";", ":", "(", ")", "[", "]", "!", "?", "'", Chr(34)
+                        sOut$ = sOut$ + Mid(sText$, lPtr, 1)
+                        lPtr = lPtr + 1
+                        If lPtr > lEnd Then
+                            Exit Do
+                        End If
+                    Case LocalMarcRecordObject.MarcDelimiter
+                        sOut$ = sOut$ + Mid(sText$, lPtr, 2)
+                        lPtr = lPtr + 2
+                        If lPtr > lEnd Then
+                            Exit Do
+                        End If
+                    Case Else
+                            Exit Do
+                End Select
+            Loop
+            If lPtr > lEnd Then
+                Exit Do
+            End If
+            
+        Loop ' for each syllable
+        
+    End If
+    
+    'DumpRomanizationTables
+    
+
+
+    ReRomanizeTextDetails = sOut$
+    
+End Function
+
+Public Function EvaluateFirstCharacter(ByVal sText$, ByVal iRomanizationTable%, ByRef LocalMarcCharacter As Utf8CharClass) As Integer
+
+    Dim lPtr As Long, lLength As Long
+        
+    Dim iLength%
+    
+        
+
+    EvaluateFirstCharacter = ROMANIZATIONDIRECTION_Unknown%
+        
+    If iRomanizationTable% < 1 Or iRomanizationTable% > gbliRomanizationTableLast% Then
+        ' do nothing: already set to unknown
+    Else
+        With gblaRomanizationTable(iRomanizationTable%)
+
+            ' first determination: are we converting script from vernacular into
+            '   roman or from roman into vernacular: the first charcter will tell
+            '   us everything we need to know
+            lPtr = 1
+            lLength = Len(sText$)
+            Do While lPtr <= lLength
+                LocalMarcCharacter.Utf8Char = Mid(sText$, lPtr)
+                If LocalMarcCharacter.Utf8Char = LocalMarcCharacter.MarcDelimiter Then
+                    ' we'll skip this, and the following character, but do nothing
+                    '   about either of 'em
+                    iLength% = 2
+                Else
+                    iLength% = LocalMarcCharacter.Utf8CharOctets
+    #If EvaluateFirstCharacterDebug = -1 Then
+                    Debug.Print "Char: >" + LocalMarcCharacter.Utf8Char + "< " + str(iLength%)
+    #End If
+                    If .Roman2Vernacular.Exists(LocalMarcCharacter.Utf8Char) Then
+                        EvaluateFirstCharacter = ROMANIZATIONDIRECTION_Roman2Vernacular%
+                        Exit Do
+                    ElseIf .Vernacular2Roman.Exists(LocalMarcCharacter.Utf8Char) Then
+                        EvaluateFirstCharacter = ROMANIZATIONDIRECTION_Vernacular2Roman%
+                        Exit Do
+                    End If
+                End If
+                lPtr = lPtr + iLength%
+            Loop
+        End With
+    End If
+    
+End Function
+
+Public Function ReRomanizeTextDetailsReplaceApostrophes(ByVal sString$, ByVal iRomanizationTable%, ByRef LocalCharacterObject As Utf8CharClass, ByRef iLengthBeforeApostropheSubstitution%) As String
+
+    Dim lPtr As Long
+    
+    Dim iLen%
+    
+    Dim sSaveIncomingCharacter$, sOut$
+    
+    'Debug.Print "RRTDRA received: >" + sString$ + "<"
+    iLengthBeforeApostropheSubstitution% = Len(sString$)
+    
+    If Not gblaRomanizationTable(iRomanizationTable%).ApostropheCharactersPresent Then
+        sOut$ = sString$
+    Else
+        sSaveIncomingCharacter$ = LocalCharacterObject.Utf8Char
+        lPtr = 1
+        Do While lPtr <= iLengthBeforeApostropheSubstitution%
+            LocalCharacterObject.Utf8Char = Mid(sString$, lPtr)
+            If InStr(gblaRomanizationTable(iRomanizationTable%).ApostropheCharacters, LocalCharacterObject.Utf8Char) > 0 Then
+                sOut$ = sOut$ + "'"
+            Else
+                sOut$ = sOut$ + LocalCharacterObject.Utf8Char
+            End If
+            lPtr = lPtr + LocalCharacterObject.Utf8CharOctets
+        Loop
+        LocalCharacterObject.Utf8Char = sSaveIncomingCharacter$
+    End If
+
+    ReRomanizeTextDetailsReplaceApostrophes = sOut$
+
+    'Debug.Print "RRTDRA output: >" + sOut$ + "<"
+    
+End Function
+
+Public Function RomanizationAssistance(ByVal iAction As RomanizationAction, ByRef LocalRichTextBox As Control, ByVal iScript%, ByRef LocalMarcRecordObjectAlreadyLoadedWithRecord As Utf8MarcRecordClass, ByRef LocalMarcCharacterObject As Utf8CharClass, ByVal iFldTextFormattedOption%, Optional ByVal sFontNameForDisplay$ = TextFormattedDefaultFont$, Optional ByVal iFontSizeForDisplay% = 10, Optional ByVal iFixedFieldDisplayConvention% = 2) As Integer
+
+    Dim sField$, sTag$, sTagToFind$, sIndicators$, s880Indicators$, sNative6$, s8806$, sLeftEnd$, sRecord$, sSubfield6Code$
+    Dim sSelText$, sLeft$, sLeft2$, sRight$, sRight2$, sRightAfterSelection$, sWholeField$
+    Dim sWord$, sNewField$, sOldField$, sFile$, sTempFile$, sLine$, sNewCharacter$
+    Dim sFieldRemainderRight$, sFieldRemainderLeft$, s6$, sOriginalField$, sType$
+    Dim sTagToCopy$, sIndicatorsToCopy$, sFieldToCopy$, sNewFields$, sOldFields$
+    Dim sSubfieldsExcludedUniversally$, sSubfieldsExcludedByTag$, sOriginalLeft$, sOriginalRight$
+    Dim sNonfilingString$, sIntermediate$
+    Dim sRLM$, sLRE$, sPDF$
+    Dim sRtfFontName$
+    
+    Dim iRc%, iRc2%, iRepeat%, iNext6%, iRomanizationStyle%, iDirection%, iIn%, iOut%, iElement%
+    Dim iLen%
+    
+    Dim lPtr As Long, lPtr2 As Long, lSelLength As Long, lSelStart As Long, lStart As Long
+    Dim lFldPointer As Long, lFldPointer2 As Long, lEnd As Long, lOriginalSelStart As Long
+        
+    Dim bFound As Boolean, bSkipTagTest As Boolean, bStringHasTerminalSpace As Boolean
+    Dim bOnlyMarc8 As Boolean, bCreateEmpty880s As Boolean, bLcPattern As Boolean
+    
+    'Const sLineEnd = "\line"
+    Const sLineEnd$ = "\par"
+    Const iLineEndLen% = 5
+    
+    ' 20180926 Bucknum: check for and use custom language/script font for RTF display
+    '   overrides the default Unicode font setting
+    sRtfFontName$ = gblaRomanizationTable(iScript%).FontName
+    If LenB(sRtfFontName$) = 0 Or Not IsFontInstalled(sRtfFontName$) Then
+        sRtfFontName$ = sFontNameForDisplay$
+    End If
+
+    If gblaRomanizationTable(iScript%).R2VCreateEmpty880s Then
+        ' 20070425: pick up a script identification code if it's been defined
+        '   otherwise, we'll attempt to match it to the language code in 008/35-37
+        '   we'll include this in $6 of "empty" 880 fields
+        ' 20070830: LC addition: if there is no such code, pick up
+        '   a transmogrification of the langauge code instead; area reorganized
+        sSubfield6Code$ = gblaRomanizationTable(iScript%).R2VSubfield6Code
+        If LenB(sSubfield6Code$) = 0 Then
+            sSubfield6Code$ = Language2ScriptCode(LocalMarcRecordObjectAlreadyLoadedWithRecord.Get008Value(35, 3))
+        End If
+        If LenB(sSubfield6Code$) > 0 Then
+            If sSubfield6Code$ = CHARACTERSET_CODES_FOR_880_HebrewAsG0$ Or _
+               sSubfield6Code$ = CHARACTERSET_CODES_FOR_880_BasicArabicAsG0$ Then
+                ' add R2L orientation code
+                sSubfield6Code$ = sSubfield6Code$ & "/r"
+            End If
+            ' add "/" prefix
+            sSubfield6Code$ = "/" + sSubfield6Code$
+        End If
+    End If
+
+    If gblaRomanizationTable(iScript%).R2VIncludeFormattingCharactersLcPattern Or _
+       InStr(sSubfield6Code$, "/r") > 0 Then
+        ' set IncludeFormattingCharactersLcPattern = True to insert UFCs
+        ' 20070830: Bucknum code forces value of this here; but we think
+        '   this should come from the configuration file
+        ' instead, we're going to set directly what DB was using this
+        '   as a proxy for
+        'gblaRomanizationTable(iScript%).R2VIncludeFormattingCharactersLcPattern = True
+        bLcPattern = True
+        ' 20070710: set a variable for the MarcRightToLeftMarker
+        '   LC wants a RTL marker before and after each delimiter,
+        '   EXCEPT immediately following the $6 code itself
+        With LocalMarcRecordObjectAlreadyLoadedWithRecord
+            sRLM$ = .MarcRightToLeftMarker
+            sLRE$ = .MarcLeftToRightEmbedding
+            sPDF$ = .MarcPopDirectionalFormatting
+        End With
+    Else
+        ' set IncludeFormattingCharactersLcPattern = False to not insert UFCs
+        ' 20070830: Bucknum code forces value of this here; but we think
+        '   this should come from the configuration file
+        ' instead, we're going to leave sRLM at its ground state of null,
+        '   which seems to be the point of all of this, anyway
+        'gblaRomanizationTable(iScript%).R2VIncludeFormattingCharactersLcPattern = False
+        bLcPattern = False
+    End If
+    
+
+
+    sType$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcRecordFormat
+    
+    ' assume everything will be OK
+    RomanizationAssistance = ROMANIZATIONRESULT_Success%
+    
+    Select Case iAction
+
+        Case ROMANIZATIONACTION_RomanizeHighlightedText%, ROMANIZATIONACTION_LCaseWord%, ROMANIZATIONACTION_UCaseWord%, ROMANIZATIONACTION_ReplaceText%, ROMANIZATIONACTION_UCaseEach%, ROMANIZATIONACTION_Define%
+        
+            ' 20070830: NoRomanization added
+            If gblaRomanizationTable(iScript%).NoRomanization Then
+                If iAction = ROMANIZATIONACTION_Define% Then
+                    GoTo RomanizationAssistanceNoFileOpenResume
+                End If
+            End If
+        
+            ' these have similar complicated beginnings, so we'll do some code-sharing
+            
+            ' get the current state of the MARC record
+            
+            ' isolate the selected text, remove any carriage returns and line feeds
+            sField$ = LocalRichTextBox.SelRTF
+
+
+            ' for some reason, delimiters are getting converted to something we don't recognize ...
+            sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sField$, "\'87", "\u8225?")
+            ' 20180926 added by Bucknum: for some reason, the rich text box is inserting alternating font codes
+            '   (e.g., "\f0") into the selected text, which is corrupting it, so we're going to strip them out
+            If InStr(sField$, "\f0 ") Or InStr(sField$, "\f1 ") Then
+                sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sField$, "\f0 "), "\f1 ")
+            ElseIf InStr(sField$, "\f0") Or InStr(sField$, "\f1") Then
+                sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sField$, "\f0"), "\f1")
+            End If
+            'Debug.Print "Initial extraction of field: >" + sField$ + "< len " + str(LocalRichTextBox.SelLength)
+            If Len(sField$) = 0 Or LocalRichTextBox.SelLength = 0 Then
+                'Debug.Print "Action: " + str(ROMANIZATIONACTION_RomanizeHighlightedText%)
+                If iAction = ROMANIZATIONACTION_RomanizeHighlightedText% Then
+                    ' 20070830: if we are clicked somewhere within a field and the selection length
+                    '   is zero, we'll assume that what we really want to do is convert the
+                    '   whole field
+                    lPtr = FindFieldCurrentlyPointedTo(LocalRichTextBox, LocalMarcRecordObjectAlreadyLoadedWithRecord)
+                    'Debug.Print "Ptr: " + str(lPtr)
+                    ' 20100402 changed by Bucknum to allow for returned default of -1 (i.e. no text selected):
+                    'If lPtr = 0 Then
+                    If lPtr <= 0 Then
+                        RomanizationAssistance = ROMANIZATIONRESULT_TextNotHighlighted%
+                        Exit Function
+                    End If
+                Else
+                    RomanizationAssistance = ROMANIZATIONRESULT_TextNotHighlighted%
+                    Exit Function
+                End If
+                ' if we get here, we've found the field of interest
+                LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lPtr
+                sFieldRemainderLeft$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldInd
+                sFieldRemainderRight$ = ""
+                sWholeField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText
+                ' 20100202 added by Bucknum: to enable
+                '  non-empty field transliteration below
+                sTag$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag
+                sIndicators$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldInd
+                sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText
+                GoTo RA_WeHaveOurFieldTheEasyWay
+            End If
+            
+            ' if we ended up with carriage returns or line feeds, remove them (inserting no space)
+            sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sField$, vbCr, ""), vbLf, "")
+            
+            ' we'll use these two values in a bit, to find the field
+            '   within the non-RTF version of the record
+            ' NOTE that the TextRTF returns delimiters correctly (as opposed to SelRTF, as
+            '   shown above) so we don't need to do any conversion here; in any case, this
+            '   step appears to be irrelevant, because we replace this value of sRecord with
+            '   a fresh copy of the TextFormatted(rtf) version of the record before we
+            '   ever use sRecord for anything; go figure
+            ' see note below about the contents of SelStart for rich text boxes
+            lSelStart = LocalRichTextBox.SelStart
+            lOriginalSelStart = lSelStart
+            
+RomanizationAssistanceReloop:
+            
+            sRecord$ = LocalRichTextBox.TextRTF
+            
+            ' remove the closing brace from the selected text
+            If Right(sField$, 1) = "}" Then
+                sField$ = Mid(sField$, 1, Len(sField$) - 1)
+            End If
+            ' remove the RTF prefix from the selected text
+            iRc% = InStr(sField$, "}}")
+            If iRc% > 0 Then
+                sField$ = Trim(Mid(sField$, iRc% + 2))
+            End If
+            ' text should now start with some additional 'slash' commands, which
+            '   we will proceed to remove
+            Do While Mid(sField$, 1, 1) = "\"
+                If Mid(sField$, 1, 2) = "\u" Then
+                    If InStr("0123456789", Mid(sField$, 3, 1)) > 0 Then
+                        Exit Do
+                    End If
+                End If
+                sField$ = Mid(sField$, 2)
+                iRc% = InStr(sField$, "\")
+                If iRc% = 0 Then
+                    iRc% = InStr(sField$, " ")
+                    If iRc% > 0 Then
+                        sField$ = Mid(sField$, iRc% + 1)
+                        Exit Do
+                    End If
+                Else
+                    iRc2% = InStr(sField$, " ")
+                    If iRc2% > 0 Then
+                        If iRc% < iRc2% Then
+                            sField$ = Mid(sField$, iRc%)
+                        Else
+                            sField$ = Mid(sField$, iRc2% + 1)
+                            Exit Do
+                        End If
+                    Else
+                        sField$ = Mid(sField$, iRc%)
+                    End If
+                End If
+            Loop
+            ' remove any trailing 'par' command
+            iRc% = LocalMarcRecordObjectAlreadyLoadedWithRecord.Rat(sField$, "\par")
+            If iRc% > 0 Then
+                sField$ = Mid(sField$, 1, iRc% - 1)
+            End If
+            If Len(sField$) = 0 Then
+                RomanizationAssistance = ROMANIZATIONRESULT_HighlightedTextBecomesNothing%
+                Exit Function
+            End If
+            ' wrapping spaces are irrelevant
+            sField$ = Trim(sField$)
+
+            ' we should now have the raw text of interest, isolated in sField$
+            
+            ' oddly enough, the SelStart property of the rich text box
+            '   refers to the plain text version
+            '   of the field; there doesn't seem to be a corresponding SelStartRtf
+            '   or anything else useful; so we're going to use the supplied SelStart
+            '   property as a rough guide for finding the selection ourselves
+            ' remembering that SelStart is zero-based (so we don't have to back up 1
+            '   from lSelStart to find the "real" end of the preceding text, and we
+            '   have to add 1 to the combined start and length to find the beginning
+            '   of whatever follows the text (which is, from our point of view, possibly
+            '   irrelevant)
+            sFieldRemainderLeft$ = Mid(LocalRichTextBox.Text, 1, lSelStart)
+            lPtr = LocalMarcRecordObjectAlreadyLoadedWithRecord.Rat(sFieldRemainderLeft$, vbLf)
+
+            If lPtr > 0 Then
+                sFieldRemainderLeft$ = Trim(Mid(sFieldRemainderLeft$, lPtr + 1) + sField$)
+                sTagToFind$ = Mid(sFieldRemainderLeft$, 1, 3)
+            Else
+                RomanizationAssistance = ROMANIZATIONRESULT_TextNotFindable%
+                Exit Function
+            End If
+            
+            Select Case LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcRecordFormat
+                Case "A"
+                    sNonfilingString$ = sAuthorityNonfilingString$
+                Case "B", "D", "F", "M", "P", "S", "U"
+                    sNonfilingString$ = sBibliographicNonfilingString$
+                'Case else: ignore the whole issue
+            End Select
+            
+            ' to help us find the highlighted text within the record,
+            '   give us the RTF version of the whole MARC record again
+            ' we don't need to worry here about specification for fixed fields or
+            '   font size, because they don't affect what we're up to here
+            sRecord$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.TextFormatted(rtfText)
+
+            lStart = 1
+            Do
+                ' find the next occurrence of our text in the record
+                lSelStart = InStr(lStart, sRecord$, sField$)
+                DoEvents
+
+                If lSelStart = 0 Then
+                    If lStart = 1 Then
+                        RomanizationAssistance = ROMANIZATIONRESULT_TextNotFindable%
+                        Exit Function
+                    End If
+                    ' we found at least one place already; so let's back up to find
+                    '   the first one (assuming that the first one is the right one!)
+                    lSelStart = InStr(1, sRecord$, sField$)
+                    If lSelStart = 0 Then
+                        RomanizationAssistance = ROMANIZATIONRESULT_TextNotFindable%
+                        Exit Function
+                    End If
+                    bSkipTagTest = True
+                Else
+                    lStart = lSelStart + 1
+                End If
+                sLeft$ = Mid(sRecord$, 1, lSelStart - 1)
+                sRight$ = Mid(sRecord$, lSelStart + Len(sField$))
+
+                ' sLeft$ = all of the record up to our selected text
+                ' sRight$ = and all of the record that follows the selected text
+                ' we want to back up in sLeft to the beginning of the current "line" (i.e., variable field)
+                lSelStart = LocalMarcRecordObjectAlreadyLoadedWithRecord.Rat(sLeft$, sLineEnd$)
+                If lSelStart > 0 Then
+                    sFieldRemainderLeft$ = LTrim(Mid(sLeft$, lSelStart + 5))
+                    If Mid(sFieldRemainderLeft$, 1, 2) = "\f" Then
+                        sLeft$ = sLeft$ + Mid(sFieldRemainderLeft$, 1, 4)
+                        sFieldRemainderLeft$ = Mid(sFieldRemainderLeft$, 5)
+                    End If
+                Else
+                    sFieldRemainderLeft$ = ""
+                End If
+
+                If Mid(LTrim(sFieldRemainderLeft$ + sField$), 1, 3) = sTagToFind$ Or bSkipTagTest Then
+                    ' we want to include from sRight any remainder of the current line (i.e., the
+                    '   remainder of our variable field)
+                    lSelStart = InStr(sRight$, sLineEnd$)
+                    If lSelStart > 1 Then
+                        sFieldRemainderRight$ = Mid(sRight$, 1, lSelStart - 1)
+                    Else
+                        sFieldRemainderRight$ = ""
+                    End If
+                    sFieldRemainderLeft$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.TranslateRTF2Marc(sFieldRemainderLeft$)
+                    sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.RemoveSpacesAroundDelimiters(LocalMarcRecordObjectAlreadyLoadedWithRecord.TranslateRTF2Marc(sField$))
+                    sFieldRemainderRight$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.TranslateRTF2Marc(sFieldRemainderRight$)
+                    sWholeField$ = Trim(sFieldRemainderLeft$ + sField$ + sFieldRemainderRight$)
+                    Exit Do
+                End If
+            Loop
+
+            'Debug.Print "Easy way"
+
+
+            Select Case iAction
+            
+                Case ROMANIZATIONACTION_RomanizeHighlightedText%
+                    sTag$ = Mid(sWholeField$, 1, 3) ' the tag of the current field
+                    sIndicators$ = Mid(sWholeField$, 5, 2)
+                    sWholeField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.RemoveSpacesAroundDelimiters(Trim(Mid(sWholeField$, 8)))
+                    If Mid(sWholeField$, 1, 2) = "\f" Then
+                        sWholeField$ = Mid(sWholeField$, 4)
+                    End If
+RA_WeHaveOurFieldTheEasyWay:
+                    'Debug.Print "Pieces: >" + sTag$ + "< >" + sIndicators$ + "< >" + sWholeField$ + "<"
+    
+                    ' change 880 $6 6xx-xx 2nd indicator to "4" (source not specified)
+                    If sTag$ >= 600 And sTag$ <= 651 Then
+                        s880Indicators$ = Mid$(sIndicators$, 1, 1) & "4"
+                    Else
+                        s880Indicators$ = sIndicators$
+                    End If
+                    
+                    iRc% = InStr(sWholeField$, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6")
+                    If iRc% > 0 Then
+                        ' 20070830: NoRomanization added
+                        If gblaRomanizationTable(iScript%).NoRomanization Then
+                            ' if we we're not actually converting text then there's nothing for us to do
+                            '   if $6 is present
+                            GoTo RomanizationAssistanceNoFileOpenResume
+                        End If
+                        s6$ = Mid(sWholeField$, iRc% + 2)
+                        iRc% = InStr(s6$, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter)
+                        If iRc% > 0 Then
+                            s6$ = Mid(s6$, 1, iRc% - 1)
+                        End If
+                    Else
+                        ' field does not yet contain $6
+                        ' calculate the next value for sequence of subfield $6
+                        LocalMarcRecordObjectAlreadyLoadedWithRecord.FldMoveTop
+                        Do While LocalMarcRecordObjectAlreadyLoadedWithRecord.FldMoveNext
+                            If LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdFindFirst("6") Then
+                                iRc% = InStr(LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, "-")
+                                If iRc% > 0 Then
+                                    iRepeat% = Val(Trim(Mid(LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, iRc% + 1)))
+                                    If iRepeat% > iNext6% Then
+                                        iNext6% = iRepeat%
+                                    End If
+                                End If
+                            End If
+                        Loop
+                        iNext6% = iNext6% + 1
+                        ' 20070830: NoRomanization added
+                        If gblaRomanizationTable(iScript%).NoRomanization Then
+                            ' if we're not actually converting text, then (until we hear more
+                            '   from David B. at LC) we're going to add $6 to the current field and
+                            '   copy the current field to 880
+                            ' we can do this much, now that we've got the next repeat number
+                            '   calculated
+                            bFound = False
+                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldMoveTop
+                            Do While LocalMarcRecordObjectAlreadyLoadedWithRecord.FldFindNext(sTag$)
+                                If LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sWholeField$ Then
+                                    lFldPointer = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                                    bFound = True
+                                End If
+                            Loop
+                            If Not bFound Then
+                                RomanizationAssistance = ROMANIZATIONRESULT_FieldNotFound%
+                                Exit Function
+                            End If
+                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer
+                            sTag$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag
+                            sIndicators$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldInd
+                            ' change 880 $6 6xx-xx 2nd indicator to "4" (source not specified)
+                            If sTag$ >= 600 And sTag$ <= 651 Then
+                                s880Indicators$ = Mid$(sIndicators$, 1, 1) & "4"
+                            Else
+                                s880Indicators$ = sIndicators$
+                            End If
+                            sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText
+                            LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdMoveFirst
+                            
+                            bOnlyMarc8 = LocalMarcRecordObjectAlreadyLoadedWithRecord.Utf8TextContainsOnlyMarc8Characters(sField$)
+                            'Debug.Print "Only marc 8? " + str(bOnlyMarc8)
+                            ' 20100412 changed by David Bucknum: since we're romanizing the field above
+                            ' original version:
+                            'LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdAdd "6", "880-" + Right("00" + Trim(str(iNext6%)), 2)
+                            ' replacement:
+                            With LocalMarcRecordObjectAlreadyLoadedWithRecord
+                                .FldDelete
+                                .FldAdd .FldTag, .FldInd, .MarcDelimiter + "6" + "880-" + Right("00" + Trim(str(iNext6%)), 2) + sField$
+                            End With
+                            ' adding subfield $6 has the effect of deleting the original field and replacing
+                            '   it with a new one; so we need to reset the pointer too
+                            lFldPointer = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                            ' 20100412 changed by David Bucknum: since we're romanizing the field above
+                            ' original version:
+                            'LocalMarcRecordObjectAlreadyLoadedWithRecord.FldAdd "880", s880Indicators$, sField$
+                            'LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdAdd "6", sTag$ + "-" + Right("00" + Trim(str(iNext6%)), 2)
+                            ' replacement:
+                            With LocalMarcRecordObjectAlreadyLoadedWithRecord
+                                .FldAdd .FldTag, .FldInd, .MarcDelimiter + "6" + sTag$ + "-" + Right("00" + Trim(str(iNext6%)), 2) + sField$
+                            End With
+                            lFldPointer2 = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                            ' now, the matrix of options
+                            If bOnlyMarc8 Then
+                                ' the field we copied into the 880 contains only MARC-8 characters; so
+                                '   we assume that this is romanized text for which we need to
+                                '   supply the vernacular form
+                                'Debug.Print "Create empty 1? " + str(gblaRomanizationTable(iScript%).R2VCreateEmpty880s)
+                                If gblaRomanizationTable(iScript%).R2VCreateEmpty880s Then
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer2
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdMoveFirst
+                                    Do While True
+                                        If InStr("68", LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode) = 0 Then
+                                        ' include this subfield, but change it to a plus sign
+                                            ' 20070831: in the new "empty" 880 field:
+                                            '   add RLMs before and after the delimiter/subfield codes,
+                                            '   as appropriate, but *only* if the Right2LeftMark variable is set
+                                            If bLcPattern Then
+                                                ' 20070831: add a LeftToRightEmbedding character (LRE) only before
+                                                '   and add a POPDirectionalFormatting character (PDF) only
+                                                '   at the end of the 880 $6 260-xx $c [dates]
+                                                ' 20121121: added 264 (RDA) to logic
+                                                If sTag$ Like "26[04]" And LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode = "c" Then
+                                                    ' if the 260 ends with a period, place the period after the PDF
+                                                    If Right(LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, 1) = "." Then
+                                                        LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText = sRLM$ + sLRE$ + "+" + sPDF$ + "."
+                                                    Else
+                                                        LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText = sRLM$ + sLRE$ + "+" + sPDF$
+                                                    End If
+                                                Else
+                                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText = sRLM$ + "+" + sRLM$
+                                                End If
+                                            Else
+                                                LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText = "+"
+                                            End If
+                                        Else
+                                            ' 20070831: add an RLM at the end of $6 as appropriate
+                                            If bLcPattern Then
+                                                LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText = LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText + sSubfield6Code$ + sRLM$
+                                            Else
+                                                LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText = LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText + sSubfield6Code$
+                                            End If
+                                        End If
+                                        If Not LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdMoveNext Then
+                                            ' 20070831: remove the final RLM at the end of the field
+                                            If bLcPattern And Right(LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText, 3) = sRLM$ Then
+                                                LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = Left(LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText, Len(LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText) - 3)
+                                            End If
+                                            Exit Do
+                                        End If
+                                    Loop
+                                End If
+                            Else
+                                ' the field we copied into the 880 contains non-MARC-8 characters; so
+                                '   we assume that this is vernacular text and the original field
+                                '   needs to be romanized
+                                'Debug.Print "Create empty 2? " + str(gblaRomanizationTable(iScript%).V2RCreateEmptyFields)
+                                If gblaRomanizationTable(iScript%).V2RCreateEmptyFields Then
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdMoveFirst
+                                    sField$ = ""
+                                    Do While True
+                                        If InStr("68", LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode) = 0 Then
+                                            ' include this subfield, but change it to a plus sign
+                                            sField$ = sField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode + "+"
+                                        Else
+                                            sField$ = sField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText
+                                        End If
+                                        If Not LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdMoveNext Then
+                                            Exit Do
+                                        End If
+                                    Loop
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sField$
+                                End If
+                            End If
+'                            LocalMarcRecordObjectAlreadyLoadedWithRecord.DumpArray "100 880", True
+                            GoTo RomanAssist_DisplayTheFinishedRecord
+                        End If
+                    End If
+                    
+
+                    iRomanizationStyle% = EvaluateFirstCharacter(sField$, iScript%, LocalMarcCharacterObject)
+
+                    If iRomanizationStyle% = ROMANIZATIONDIRECTION_Unknown% Then
+
+                        RomanizationAssistance = ROMANIZATIONRESULT_ActionUnclear%
+                        Exit Function
+                    End If
+                    
+
+                    ' at this point we need to make the critical determination: are we converting
+                    '   romanized text into vernacular, or are we converting vernacular text into romanized?
+                    ' here go the scenarios we've developed, based on a
+                    '   matrix of these factors:
+                    '   1) whether the field is 880, or something else
+                    '   2) whether the field already contains subfield $6
+                    '   3) whether the highlighted text is vernacular or romanized
+                    If sTag$ <> "880" Then
+                        If Len(s6$) = 0 Then
+                            ' we need lFldPointer regardless of what happens
+                            '   to remaining scenarios here
+                            bFound = False
+                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldMoveTop
+                            Do While LocalMarcRecordObjectAlreadyLoadedWithRecord.FldFindNext(sTag$)
+                                'Debug.Print "Comparing: >" + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText + "< >" + sWholeField$ + "<"
+                                If LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sWholeField$ Then
+                                    lFldPointer = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                                    bFound = True
+                                End If
+                            Loop
+                            If Not bFound Then
+                                RomanizationAssistance = ROMANIZATIONRESULT_FieldNotFound%
+                                Exit Function
+                            End If
+                            If iRomanizationStyle% = ROMANIZATIONDIRECTION_Vernacular2Roman% Then
+                                ' not an 880 field; no $6 yet; we're moving from vernacular to romanized
+                                ' copy the current field as 880 (which adds $6 to the
+                                '   original field and also the new 880 field); otherwise
+                                '   leave the 880 field alone
+                                iRc% = InStr(sWholeField$, sField$)
+                                If iRc% > 0 Then ' it sure better be!
+RomanAssist_ReplayWithSubstitution:
+                                    ' find the original field (again!) and get a copy of it
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldLoadInfo sTagToCopy$, sIndicatorsToCopy$, sFieldToCopy$
+                                    lFldPointer2 = lFldPointer
+                                    ' copy the field as it stands to an 880, with $6 added
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldAdd "880", sIndicatorsToCopy$, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + sTagToCopy$ + "-" + Right("00" + Trim(str(iNext6%)), 2) + sSubfield6Code$ + sFieldToCopy$
+                                    ' save the pointer to the new 880 field for later use in resolving
+                                    '   the nonfiling characters indicator
+                                    lFldPointer = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                                    
+                                    ' isolate the bits that we're NOT going to romanize
+                                    sLeft$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6880-" + Right("00" + Trim(str(iNext6%)), 2) + Mid(sWholeField$, 1, iRc% - 1)
+
+                                    If Right(sLeft$, 1) = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter Then
+                                        sLeft$ = Mid(sLeft$, 1, Len(sLeft$) - 1)
+                                        sIntermediate$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter
+                                    ElseIf Mid(Right(sLeft$, 2), 1, 1) = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter Then
+                                        sIntermediate$ = Right(sLeft$, 2)
+                                        sLeft$ = Mid(sLeft$, 1, Len(sLeft$) - 2)
+                                    End If
+
+                                    sRight$ = Mid(sWholeField$, iRc% + Len(sField$))
+                                    sField$ = sIntermediate$ + sField$
+
+                                    ' change the text of the native field to match
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer2
+                                    If Right(sField$, 1) = " " Then
+                                        bStringHasTerminalSpace = True
+                                    Else
+                                        bStringHasTerminalSpace = False
+                                    End If
+                                    ' 20070731: make sure first word is uppercased
+                                    sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.UCaseFirstWord(ReRomanizeText(sType$, LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag, sField$, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject))
+                                    If Not bStringHasTerminalSpace Then
+                                        sField$ = RTrim(sField$)
+                                    End If
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sLeft$ + sField$ + sRight$
+                                    ' just in case we've done a delete/re-add
+                                    lFldPointer2 = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                                    
+                                    ' adjust nonfiling characters as necessary
+#If RomanizationAssistanceDebug = -1 Then
+                                    Debug.Print "Adjust NON #1"
+#End If
+                                    ReRomanizeAdjustNonfilingIndicators iScript%, sNonfilingString$, lFldPointer, lFldPointer2, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject
+                                    
+                                    GoTo RomanAssist_DisplayTheFinishedRecord
+                                    
+                                Else
+                                    iRc% = InStr(sField$, sWholeField$)
+                                    If iRc% > 0 Then
+                                        sField$ = sWholeField$
+                                        iRc% = InStr(sWholeField$, sField$)
+                                        If iRc% > 0 Then
+                                            GoTo RomanAssist_ReplayWithSubstitution
+                                        End If
+                                    End If
+                                    ' todo: if we get here, nothing is going to happen; tell the operator?
+                                End If
+                            Else ' not an 880 field; no $6 yet; we're moving from romanized to vernacular
+                                ' find the field in the bib record
+                                ' INCLUDES Wade-Giles to Pinyin
+                                iRc% = InStr(sWholeField$, sField$)
+
+                                If iRc% > 0 Then ' it sure better be!
+RomanAssist_ReplayWithSubstitution2:
+                                    ' isolate the bits that we're NOT going to romanize
+                                    sRight$ = Mid(sWholeField$, iRc% + Len(sField$))
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer
+
+                                    sTagToCopy$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag
+                                    If gblaRomanizationTable(iScript%).DoNotUse880Field Then
+                                        ' probably wade-giles to pinyin
+                                        sLeft$ = Mid(sWholeField$, 1, iRc% - 1)
+                                        LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sLeft$ + ReRomanizeText(sType$, LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag, sField$, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject) + sRight$
+                                    Else
+                                        sLeft$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + sTag$ + "-" + Right("00" + Trim(str(iNext6%)), 2) + sSubfield6Code$ + Mid(sWholeField$, 1, iRc% - 1)
+                                        ' add subfield $6 to the original field (to make things easier, we'll
+                                        '   actually achieve this with a delete/insert operation)
+                                        'Debug.Print "Text before delete: " + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText
+                                        LocalMarcRecordObjectAlreadyLoadedWithRecord.FldDelete
+                                        ' 20070703: in the original version (retained here as a comment), we use the text of the new field
+                                        '   as run through the ReRomanize function. the reason for this is not clear, and
+                                        '   at least in the Hebrew stuff we're testing with just now this results in
+                                        '   a field with uppercase letters rendered as lowercase
+                                        ' the obvious solution appears to be to use the original field text in the
+                                        '   new field, without any changes
+                                        ' perhaps only time will reveal the need that led to our use of ReRomanize
+                                        '   here in the first place ...
+                                        ' original version:
+                                        'LocalMarcRecordObjectAlreadyLoadedWithRecord.FldInsertAfter sTagToCopy$, sIndicators$, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + "880-" + Right("00" + Trim(str(iNext6%)), 2) + ReRomanizeText(sType$, LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag, LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject, 2)
+                                        ' replacement:
+                                        ' 20100809 Bucknum added: remove temporary VowelMarker character before export
+                                        If LenB(gblaRomanizationTable(iScript%).R2VVowelMarker) > 0 Then
+                                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText, gblaRomanizationTable(iScript%).R2VVowelMarker)
+                                        End If
+                                        LocalMarcRecordObjectAlreadyLoadedWithRecord.FldInsertAfter sTagToCopy$, sIndicators$, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + "880-" + Right("00" + Trim(str(iNext6%)), 2) + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText
+                                        ' pointer to the "changed" field
+                                        lFldPointer = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                                        ' 20070719: convert the text for the 880 here, instead of below
+                                        sField$ = ReRomanizeText(sType$, sTagToCopy$, sField$, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject)
+                                        ' add right-to-left marker to the end of subfield $6 as appropriate
+                                        If bLcPattern Then
+                                            lPtr = InStr(sLeft$, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6")
+                                            If lPtr > 0 Then
+                                                sLeft$ = sLeft$ & LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcRightToLeftMarker
+                                            End If
+                                            ' add LRE and PDF markers to the 880 $6 260-xx $c [dates]
+                                            '   after the $c RLM and at the end of the subfield
+                                            ' 20121121: added 264 (RDA) to logic
+                                            lPtr2 = InStr(sField$, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "c")
+                                            If lPtr2 <> 0 And sTagToCopy$ Like "26[04]" Then
+                                                sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.SafeStuff(sField$, lPtr2 + 5, 0, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcLeftToRightEmbedding)
+                                                ' if the subfield ends with a period, place the period after the PDF
+                                                If Right(sField$, 1) = "." Then
+                                                    sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.SafeStuff(sField$, InStrRev(sField$, "."), 1, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcPopDirectionalFormatting + ".")
+                                                Else
+                                                    sField$ = sField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcPopDirectionalFormatting
+                                                End If
+                                            End If
+                                        End If
+                                        ' create an 880 field with text converted
+                                        
+
+                                        ' 20070719 changed by David Bucknum: since we're romanizing the field above
+                                        ' original version:
+                                        'LocalMarcRecordObjectAlreadyLoadedWithRecord.FldInsertAfter "880", s880Indicators$, sLeft$ + ReRomanizeText(sType$, sTagToCopy$, sField$, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject) + sRight$
+                                        ' replacement:
+                                        LocalMarcRecordObjectAlreadyLoadedWithRecord.FldInsertAfter "880", s880Indicators$, sLeft$ + sField$ + sRight$
+                                        ' this is, for our purposes, the "original" field
+                                        lFldPointer2 = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+
+                                        'LocalMarcRecordObjectAlreadyLoadedWithRecord.DumpArray "", False
+#If RomanizationAssistanceDebug = -1 Then
+                                        Debug.Print "Adjust NON #2"
+#End If
+                                        ReRomanizeAdjustNonfilingIndicators iScript%, sNonfilingString$, lFldPointer, lFldPointer2, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject
+                                        ' does this achieve anything at all?
+                                        LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer
+
+                                    End If
+                                    GoTo RomanAssist_DisplayTheFinishedRecord
+                                Else
+                                    iRc% = InStr(sField$, sWholeField$)
+                                    If iRc% > 0 Then
+                                        sField$ = sWholeField$
+                                        iRc% = InStr(sWholeField$, sField$)
+                                        If iRc% > 0 Then
+                                            GoTo RomanAssist_ReplayWithSubstitution2
+                                        End If
+                                    End If
+                                    ' todo: if we get here, nothing is going to happen; tell the operator?
+                                End If
+                            End If
+                        Else ' tag not 880, subfield $6 is present
+
+                            If iRomanizationStyle% = ROMANIZATIONDIRECTION_Vernacular2Roman% Then
+                                ' not an 880 field; already contains $6; moving from vernacular to roman
+                                ' todo: romanize the text in place, leaving the 880 field alone
+                                ' NOTE that if field already contains $6, we're not going to
+                                '   do anything about initial articles
+RomanAssist_ReRomanizeInPlace:
+                                bFound = False
+                                sTag$ = Mid(sFieldRemainderLeft$, 1, 3)
+                                LocalMarcRecordObjectAlreadyLoadedWithRecord.FldMoveTop
+                                Do While LocalMarcRecordObjectAlreadyLoadedWithRecord.FldFindNext(sTag$)
+                                    If LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sWholeField$ Then
+                                        lFldPointer = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                                        bFound = True
+                                    End If
+                                Loop
+                                If Not bFound Then
+                                    RomanizationAssistance = ROMANIZATIONRESULT_FieldNotFound%
+                                    Exit Function
+                                Else
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer
+                                    If Len(sFieldRemainderLeft$) > 0 Then
+                                        lFldPointer = InStr(sFieldRemainderLeft$, LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter)
+                                        If lFldPointer > 0 Then
+                                            sFieldRemainderLeft$ = Mid(sFieldRemainderLeft$, lFldPointer)
+                                        End If
+                                    End If
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sFieldRemainderLeft$ + ReRomanizeText(sType$, LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag, sField$, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject) + sFieldRemainderRight$
+                                    GoTo RomanAssist_DisplayTheFinishedRecord
+                                End If
+                            Else
+                                ' not an 880 field; already contains $6; we're moving from romanized to vernacular
+                                ' todo: find the parallel text in the 880 field, and vernacularize the
+                                '   parallel text in the 880 field; leave the user-marked field alone
+                            End If
+                        End If
+                    Else
+                        ' the operator selected text within an 880 field
+                        If Len(s6$) = 0 Then
+                            RomanizationAssistance = ROMANIZATIONRESULT_880WithNoSubfield6%
+                            Exit Function
+                        Else
+                            ' 880 field; field already contains $6
+                            GoTo RomanAssist_ReRomanizeInPlace
+                        End If
+                    End If
+        
+                Case ROMANIZATIONACTION_LCaseWord%, ROMANIZATIONACTION_UCaseWord%, ROMANIZATIONACTION_ReplaceText%, ROMANIZATIONACTION_UCaseEach%, ROMANIZATIONACTION_Define%
+
+                    sTag$ = Mid(sWholeField$, 1, 3) ' the tag of the current field
+                    sIndicators$ = Mid(sWholeField$, 5, 2)
+                    sWholeField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.RemoveSpacesAroundDelimiters(Trim(Mid(sWholeField$, 8)))
+                    If Mid(sWholeField$, 1, 2) = "\f" Then
+                        sWholeField$ = Mid(sWholeField$, 4)
+                    End If
+        
+                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldMoveTop
+                    Do While LocalMarcRecordObjectAlreadyLoadedWithRecord.FldFindNext(sTag$)
+                        If LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sWholeField$ Then
+                            lFldPointer = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer
+                            bFound = True
+                        End If
+                    Loop
+                    If Not bFound Then
+                        RomanizationAssistance = ROMANIZATIONRESULT_FieldNotFound%
+                        Exit Function
+                    End If
+                
+                    iRc% = InStr(sWholeField$, sField$)
+                    If iRc% > 0 Then ' it sure better be!
+                    
+                        iRc% = InStr(sWholeField$, sField$)
+                        If iRc% > 0 Then ' it sure better be!
+                            ' find the original field (again!) and get a copy of it
+                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = lFldPointer
+                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldLoadInfo sTagToCopy$, sIndicatorsToCopy$, sFieldToCopy$
+                            ' isolate the bits that we're NOT going to romanize
+                            sLeft$ = Mid(sWholeField$, 1, iRc% - 1)
+
+
+                            If Right(sLeft$, 1) = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter Then
+                                sLeft$ = Mid(sLeft$, 1, Len(sLeft$) - 1)
+                                sIntermediate$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter
+                            ElseIf Mid(Right(sLeft$, 2), 1, 1) = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter Then
+                                sIntermediate$ = Right(sLeft$, 2)
+                                sLeft$ = Mid(sLeft$, 1, Len(sLeft$) - 2)
+                            End If
+
+                            sRight$ = Mid(sWholeField$, iRc% + Len(sField$))
+                            sField$ = sIntermediate$ + sField$
+
+                            sOriginalField$ = sField$
+                    
+                            Select Case iAction
+                                Case ROMANIZATIONACTION_LCaseWord%
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sLeft$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.LCaseFirstWord(sField$) + sRight$
+                                Case ROMANIZATIONACTION_UCaseWord%
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sLeft$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.UCaseFirstWord(sField$) + sRight$
+                                Case ROMANIZATIONACTION_ReplaceText%, ROMANIZATIONACTION_Define%
+                                    sNewField$ = ""
+                                    sOriginalLeft$ = sLeft$
+                                    sOriginalRight$ = sRight$
+                                    
+                                    Do While Len(sField$) > 0
+                                        If Asc(Mid(sField$, 1, 1)) > 127 Then
+                                            LocalMarcCharacterObject.Utf8Char = sField$
+                                            sField$ = Mid(sField$, LocalMarcCharacterObject.Utf8CharOctets + 1)
+                                            sNewField$ = sNewField$ + "{U+" + LocalMarcCharacterObject.UcsHex + "}"
+                                        Else
+                                            sNewField$ = sNewField$ + Mid(sField$, 1, 1)
+                                            sField$ = Mid(sField$, 2)
+                                        End If
+                                    Loop
+                                    If iAction = ROMANIZATIONACTION_Define% Then
+                                        sFile$ = gblaRomanizationTable(iScript%).FullFileName
+                                        sTempFile$ = sFile$
+                                        iRc2% = LocalMarcRecordObjectAlreadyLoadedWithRecord.Rat(sTempFile$, "\")
+                                        If iRc2% = 0 Then
+                                            Exit Function
+                                        End If
+                                        sTempFile$ = Mid(sTempFile$, 1, iRc2%) + "Temp.$$$"
+                                        On Error GoTo RomanizationAssistanceNoFileOpen
+                                        iOut% = FreeFile
+                                        Open sTempFile$ For Output As #iOut%
+                                        On Error GoTo 0
+                                        iIn% = FreeFile
+                                        Open sFile$ For Input As #iIn%
+                                        
+                                        iRc% = InStr(sNewField$, "{U+")
+                                        If iRc% = 0 Then
+                                            RomanizationAssistance = ROMANIZATIONRESULT_NoCharacterToDefine%
+                                            Exit Function
+                                        End If
+                                        ' iRc% points to the character in question
+                                        ' PRESERVE THE VALUE OF iRC!
+                                        sField$ = InputBox("Please supply the replacement text for U+" + Mid(sNewField$, iRc% + 3, 4) + ".  (Supply empty text to cancel.)", "Define replacement for vernacular character", "")
+                                        If Len(sField$) = 0 Then
+                                            Close #iIn%
+                                            Close #iOut%
+                                            Exit Function ' operation canceled
+                                        End If
+                                        ' iRc% still points to the character in question
+                                        ' PRESERVE THE VALUE OF iRC!
+                                        If sField$ = Mid(sNewField$, iRc% + 3, 4) Then
+                                            Close #iIn%
+                                            Close #iOut%
+                                            Exit Function ' operator didn't make a change: nothing to do
+                                        End If
+                                        ' iRc% still points to the character in question
+                                        ' PRESERVE THE VALUE OF iRC!
+                                        ' todo: if we need to allow for the possibility of Unicode
+                                        '   notations within the replacement text, handle them here
+                                        '   (not needed for Chinese, which is the object of this
+                                        '   exercise)
+                                        ' add a new line to the configuration file,
+                                        '   defining this new character (we opened the files
+                                        '   above, so we could make sure we're allowed to do this
+                                        '   before we actually go to work)
+                                        '
+                                        ' 20070606 added by David Bucknum
+                                        sField$ = Trim(sField$) & " "
+                                        Do While Not EOF(iIn%)
+                                            DoEvents
+                                            Line Input #iIn%, sLine$
+                                            Print #iOut%, sLine$
+                                            ' 20070727 (comment only; no change) this puts the new
+                                            '   character at the top of the stanza, whether we want
+                                            '   it there or somewhere else; this is "probably" good
+                                            '   enough, given the context ...
+                                            If sLine$ = "[ScriptToRoman]" Then
+                                                Print #iOut%, "U+" + Mid(sNewField$, iRc% + 3, 4) + "=" + LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sField$, " ", "_")
+                                            End If
+                                        Loop
+                                        Close #iIn%
+                                        Close #iOut%
+                                        On Error GoTo RomanizationAssistanceBadKill
+                                        Kill sFile$
+                                        DoEvents
+                                        FileCopy sTempFile$, sFile$
+                                        DoEvents
+                                        Kill sTempFile$
+                                        ' add the character to the current version of the
+                                        '   romanization tables in memory
+                                        'sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sField$, "_", " ")
+                                        ' this is the "native" representation of the whole raw string (which should
+                                        '   just be one character)
+                                        'Debug.Print "RA 1"
+                                        sNewCharacter$ = RomanizeConvertText("U+" + Mid(sNewField$, iRc% + 3, 4), LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject)
+                                        LocalMarcCharacterObject.UcsHex = Mid(sNewField$, iRc% + 3, 4) ' isolating the first character (there should only be the one)
+                                        If gblaRomanizationTable(iScript%).Vernacular2Roman.Exists(LocalMarcCharacterObject.Utf8Char) Then
+                                            iElement% = gblaRomanizationTable(iScript%).Vernacular2Roman.item(LocalMarcCharacterObject.Utf8Char)
+                                        Else
+                                            gblaRomanizationTable(iScript%).VernacularLast = gblaRomanizationTable(iScript%).VernacularLast + 1
+                                            If gblaRomanizationTable(iScript%).VernacularLast > gblaRomanizationTable(iScript%).VernacularMax Then
+                                                gblaRomanizationTable(iScript%).VernacularMax = gblaRomanizationTable(iScript%).VernacularMax + 10
+                                                ReDim Preserve gblaRomanizationTable(iScript%).Vernacular(0 To gblaRomanizationTable(iScript%).VernacularMax)
+                                            End If
+                                            iElement% = gblaRomanizationTable(iScript%).VernacularLast
+                                            gblaRomanizationTable(iScript%).Vernacular2Roman.Add LocalMarcCharacterObject.Utf8Char, iElement%
+                                        End If
+                                        gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast = gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast + 1
+                                        If gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast > gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailMax Then
+                                            gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailMax = gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailMax + 5
+                                            ReDim Preserve gblaRomanizationTable(iScript%).Vernacular(iElement%).Detail(0 To gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailMax)
+                                        End If
+                                        sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sField$, "_", " ")
+                                        gblaRomanizationTable(iScript%).Vernacular(iElement%).Detail(gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast).FullStringLengthInCharacters = LocalMarcRecordObjectAlreadyLoadedWithRecord.SafeLen(sNewCharacter$)
+                                        gblaRomanizationTable(iScript%).Vernacular(iElement%).Detail(gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast).FullStringLengthInBytes = Len(sNewCharacter$)
+                                        gblaRomanizationTable(iScript%).Vernacular(iElement%).Detail(gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast).FullString = sNewCharacter$
+                                        gblaRomanizationTable(iScript%).Vernacular(iElement%).Detail(gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast).Equivalent = sField$
+                                        gblaRomanizationTable(iScript%).Vernacular(iElement%).Detail(gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast).EquivalentUpperCasePresent = False
+                                        'Debug.Print "Defined equivalent >" + gblaRomanizationTable(iScript%).Vernacular(iElement%).Detail(gblaRomanizationTable(iScript%).Vernacular(iElement%).DetailLast).Equivalent + "< for >" + "Y" + "<"
+
+                                        If Right(sField$, 1) = " " Then
+                                            sOriginalField$ = sOriginalLeft$ + sOriginalField$ + sOriginalRight$
+                                            iRc% = InStr(sOriginalField$, sNewCharacter$)
+                                            Do While iRc% > 0
+                                                Select Case Mid(sOriginalField$, iRc% + Len(sNewCharacter$), 1)
+                                                    Case " "
+                                                        sOriginalField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.SafeStuff(sOriginalField$, iRc%, Len(sNewCharacter$), sField$)
+                                                    Case Chr(34), "'", ";", ":", ",", ".", "/", "<", ">", "?", "[", "]", "\", "{", "}", "|", "-", "=", "!", "@", "#", "$%", "^", "&", "*", "(", ")", "_", "+", ""
+                                                        sOriginalField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.SafeStuff(sOriginalField$, iRc%, Len(sNewCharacter$), Trim(sField$))
+                                                    Case Else
+                                                        sOriginalField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.SafeStuff(sOriginalField$, iRc%, Len(sNewCharacter$), sField$)
+                                                End Select
+                                                iRc% = InStr(sOriginalField$, sNewCharacter$)
+                                            Loop
+                                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = LocalMarcRecordObjectAlreadyLoadedWithRecord.RemoveRepeatedCharacters(sOriginalField$, " ")
+                                        Else
+                                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = LocalMarcRecordObjectAlreadyLoadedWithRecord.RemoveRepeatedCharacters(LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sOriginalLeft$ + sOriginalField$ + sOriginalRight$, sNewCharacter$, sField$), " ")
+                                        End If
+                                    Else
+                                        sNewField$ = InputBox("Please supply the replacement text.  Non-ASCII characters are shown as Unicode(TM) values within curly braces." + vbLf + "Original: " + sNewField$, "Replace text", sNewField$)
+                                        If Len(sNewField$) > 0 Then
+                                            Do
+                                                iRc% = InStr(sNewField$, "{U+")
+                                                If iRc% = 0 Then
+                                                    Exit Do
+                                                End If
+                                                sLeft2$ = Mid(sNewField$, 1, iRc% - 1)
+                                                sNewField$ = Mid(sNewField$, iRc% + 3)
+                                                iRc% = InStr(sNewField$, "}")
+                                                If iRc% > 1 Then
+                                                    sRight2$ = Mid(sNewField$, iRc% + 1)
+                                                    LocalMarcCharacterObject.UcsHex = Mid(sNewField$, 1, iRc% - 1)
+                                                    sNewField$ = LocalMarcCharacterObject.Utf8Char
+                                                Else
+                                                    sRight2$ = ""
+                                                End If
+                                                sNewField$ = sLeft2$ + sNewField$ + sRight2$
+                                            Loop
+                                            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sLeft$ + sNewField$ + sRight$
+                                        End If
+                                    End If
+                                Case ROMANIZATIONACTION_UCaseEach%
+                                    sNewField$ = ""
+                                    Do While Len(sField$) > 0
+                                        GetNextPiece sField$, sWord$, " "
+                                        sNewField$ = Trim(sNewField$ + " " + LocalMarcRecordObjectAlreadyLoadedWithRecord.UCaseFirstWord(sWord$))
+                                    Loop
+                                    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sLeft$ + sNewField$ + sRight$
+                            End Select
+                            
+                            GoTo RomanAssist_DisplayTheFinishedRecord
+                        End If
+                        
+                    End If
+        
+            End Select
+            
+        Case ROMANIZATIONACTION_RomanizeWholeRecord%
+            
+            ' 20070830: NoRomanization added
+'            If gblaRomanizationTable(iScript%).NoRomanization Then
+'                GoTo RomanizationAssistanceNoFileOpenResume
+'            End If
+            
+            iRc% = RomanizationAssistanceConvertWholeRecord(sType$, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject)
+
+            If iRc% <> 0 Then
+                RomanizationAssistance = iRc%
+                Exit Function
+            End If
+            
+            GoTo RomanAssist_DisplayTheFinishedRecord
+    
+        Case ROMANIZATIONACTION_DisplayMarcRecord%
+    
+RomanAssist_DisplayTheFinishedRecord:
+            
+
+            If iFldTextFormattedOption% = 99 Then
+                Select Case iFixedFieldDisplayConvention%
+                    Case 2 ' FixedFieldDisplay_OCLCMonospaced%
+                        LocalRichTextBox.TextRTF = LocalMarcRecordObjectAlreadyLoadedWithRecord.TextFormatted(rtfText, OclcMonospaced, "", True, sRtfFontName$, iFontSizeForDisplay%)
+                    Case 1 ' FixedFieldDisplay_OCLC
+                        LocalRichTextBox.TextRTF = LocalMarcRecordObjectAlreadyLoadedWithRecord.TextFormatted(rtfText, oclc, "", True, sRtfFontName$, iFontSizeForDisplay%)
+                    Case Else ' zero; notis
+                        LocalRichTextBox.TextRTF = LocalMarcRecordObjectAlreadyLoadedWithRecord.TextFormatted(rtfText, notis, "", True, sRtfFontName$, iFontSizeForDisplay%)
+                End Select
+            Else
+                Select Case iFixedFieldDisplayConvention%
+                    Case 2 ' FixedFieldDisplay_OCLCMonospaced%
+                        LocalRichTextBox.TextRTF = LocalMarcRecordObjectAlreadyLoadedWithRecord.TextFormatted(rtfTextwithlabels, OclcMonospaced, "", True, sRtfFontName$, iFontSizeForDisplay%)
+                    Case 1 ' FixedFieldDisplay_OCLC
+                        LocalRichTextBox.TextRTF = LocalMarcRecordObjectAlreadyLoadedWithRecord.TextFormatted(rtfTextwithlabels, oclc, "", True, sRtfFontName$, iFontSizeForDisplay%)
+                    Case Else ' zero; notis
+                        LocalRichTextBox.TextRTF = LocalMarcRecordObjectAlreadyLoadedWithRecord.TextFormatted(rtfTextwithlabels, notis, "", True, sRtfFontName$, iFontSizeForDisplay%)
+                End Select
+            End If
+            
+    End Select
+    
+RomanizationAssistanceNoFileOpenResume:
+
+    Exit Function
+    
+RomanizationAssistanceBadKill:
+RomanizationAssistanceNoFileOpen:
+
+
+    RomanizationAssistance = ROMANIZATIONRESULT_FileOpen%
+    On Error GoTo 0
+    Resume RomanizationAssistanceNoFileOpenResume
+    
+End Function
+
+Public Function FindFieldCurrentlyPointedTo(ByRef cRichTextBox As Control, ByRef LocalMarcRecord As Utf8MarcRecordClass, Optional ByVal bSearch As Boolean = False) As Long
+
+    ' 20070207: created (so OK for Unicode already)
+    
+    ' find in a MARC record the field that corresponds to the field-currently-clicked-on
+    '   in the rich text box
+    ' return the pointer to that field (if the pointer is nonzero, the MARC record object also
+    '   is currently pointed to that field, but the caller should probably not assume this)
+    
+    Dim lSelStart As Long, lOriginalSelStart As Long, lPtr As Long, lStart As Long
+    
+    Dim sField$, sRecord$, sFieldRemainderLeft$, sFieldRemainderRight$
+    Dim sTagToFind$, sNonfilingString$
+    Dim sLeft$, sRight$, sLineEnd$, sWholeField$
+    
+    Dim iRc%, iRc2%
+    
+    Dim bSkipTagTest As Boolean
+    
+    
+    ' assume that we didn't find anything
+    FindFieldCurrentlyPointedTo = -1
+    
+    ' this is a useful thing to have, either way
+    lSelStart = cRichTextBox.SelStart
+            
+    If Len(cRichTextBox.SelText) > 0 Then
+    
+        ' the easier way out: at least one character is highlighted (we've
+        '   already figured this out for the toolkit's re-romanization button, so we'll
+        '   just translate that bit of business for the context here)
+        lOriginalSelStart = lSelStart
+        sField$ = cRichTextBox.SelRTF
+        sRecord$ = cRichTextBox.TextRTF
+            
+        ' remove the closing brace from the selected text
+        If Right(sField$, 1) = "}" Then
+            sField$ = Mid(sField$, 1, Len(sField$) - 1)
+        End If
+        ' remove the RTF prefix from the selected text
+        iRc% = InStr(sField$, "}}")
+        If iRc% > 0 Then
+            sField$ = Trim(Mid(sField$, iRc% + 2))
+        End If
+        ' text should now start with some additional 'slash' commands, which
+        '   we will proceed to remove
+        Do While Mid(sField$, 1, 1) = "\"
+            If Mid(sField$, 1, 2) = "\u" Then
+                If InStr("0123456789", Mid(sField$, 3, 1)) > 0 Then
+                    Exit Do
+                End If
+            End If
+            sField$ = Mid(sField$, 2)
+            iRc% = InStr(sField$, "\")
+            If iRc% = 0 Then
+                iRc% = InStr(sField$, " ")
+                If iRc% > 0 Then
+                    sField$ = Mid(sField$, iRc% + 1)
+                    Exit Do
+                End If
+            Else
+                iRc2% = InStr(sField$, " ")
+                If iRc2% > 0 Then
+                    If iRc% < iRc2% Then
+                        sField$ = Mid(sField$, iRc%)
+                    Else
+                        sField$ = Mid(sField$, iRc2% + 1)
+                        Exit Do
+                    End If
+                Else
+                    sField$ = Mid(sField$, iRc%)
+                End If
+            End If
+        Loop
+        ' remove any trailing 'par' command
+        iRc% = LocalMarcRecord.Rat(sField$, "\par")
+        If iRc% > 0 Then
+            sField$ = Mid(sField$, 1, iRc% - 1)
+        End If
+        ' wrapping spaces are irrelevant
+        sField$ = Trim(sField$)
+        If Len(sField$) = 0 Then
+            ' maybe we can work this out using just the
+            '   SelStart pointer?
+            GoTo FFCPT_UseJustSelStart
+        End If
+        
+        ' in sField$ we should now have the raw RTF text of interest minus the wrapper
+        
+        ' oddly enough, the SelStart property of the rich text box
+        '   refers to the plain text version
+        '   of the field; there doesn't seem to be a corresponding SelStartRtf
+        '   or anything else useful; so we're going to use the supplied SelStart
+        '   property as a rough guide for finding the selection ourselves
+        ' remembering that SelStart is zero-based (so we don't have to back up 1
+        '   from lSelStart to find the "real" end of the preceding text, and we
+        '   have to add 1 to the combined start and length to find the beginning
+        '   of whatever follows the text (which is, from our point of view, possibly
+        '   irrelevant)
+        sFieldRemainderLeft$ = Mid(cRichTextBox.Text, 1, lSelStart)
+        lPtr = LocalMarcRecord.Rat(sFieldRemainderLeft$, vbLf)
+        If lPtr > 0 Then
+            sFieldRemainderLeft$ = Trim(Mid(sFieldRemainderLeft$, lPtr + 1) + sField$)
+            sTagToFind$ = Mid(sFieldRemainderLeft$, 1, 3)
+        Else
+            GoTo FFCPT_UseJustSelStart
+        End If
+        
+        Select Case LocalMarcRecord.MarcRecordFormat
+            Case "A"
+                sNonfilingString$ = sAuthorityNonfilingString$
+            Case "B", "D", "F", "M", "P", "S", "U"
+                sNonfilingString$ = sBibliographicNonfilingString$
+            'Case else: ignore the whole issue
+        End Select
+        
+        ' to help us find the highlighted text within the record,
+        '   give us the RTF version of the whole MARC record again
+        ' we don't need to worry here about specification for fixed fields or
+        '   font size, because they don't affect what we're up to here
+        sRecord$ = LocalMarcRecord.TextFormatted(rtfText, OclcMonospaced)
+        lStart = 1
+        Do
+            ' find the next occurrence of our text in the record
+            lSelStart = InStr(lStart, sRecord$, sField$)
+            DoEvents
+            If lSelStart = 0 Then
+                If lStart = 1 Then
+                    GoTo FFCPT_UseJustSelStart
+                End If
+                ' we found at least one place already; so let's back up to find
+                '   the first one (assuming that the first one is the right one!)
+                lSelStart = InStr(1, sRecord$, sField$)
+                If lSelStart = 0 Then
+                    GoTo FFCPT_UseJustSelStart
+                End If
+                bSkipTagTest = True
+            Else
+                lStart = lSelStart + 1
+            End If
+            sLeft$ = Mid(sRecord$, 1, lSelStart - 1)
+            sRight$ = Mid(sRecord$, lSelStart + Len(sField$))
+            ' sLeft$ = all of the record up to our selected text
+            ' sRight$ = and all of the record that follows the selected text
+            ' we want to back up in sLeft to the beginning of the current "line" (i.e., variable field)
+            lSelStart = LocalMarcRecord.Rat(sLeft$, sLineEnd$)
+            If lSelStart > 0 Then
+                sFieldRemainderLeft$ = LTrim(Mid(sLeft$, lSelStart + 5))
+                If Mid(sFieldRemainderLeft$, 1, 2) = "\f" Then
+                    sLeft$ = sLeft$ + Mid(sFieldRemainderLeft$, 1, 4)
+                    sFieldRemainderLeft$ = Mid(sFieldRemainderLeft$, 5)
+                End If
+            Else
+                sFieldRemainderLeft$ = ""
+            End If
+            If Mid(LTrim(sFieldRemainderLeft$ + sField$), 1, 3) = sTagToFind$ Or bSkipTagTest Then
+                ' this is the field we want!  hooray!
+                FindFieldCurrentlyPointedTo = LocalMarcRecord.FldPointer
+
+                Exit Function
+            End If
+        
+        Loop
+        
+        ' if we get here, we didn't find what we wanted, given the text highlighted by the
+        '   operator
+        ' we'll fall through and try the second method, using just the starting point of the
+        '   highlight
+        
+    End If
+    
+    ' if we get here, either the operator didn't highlight any text at all, or
+    '   we failed in the above attempt to find the highlighted text
+    
+FFCPT_UseJustSelStart:
+
+    ' if we *branch to* here, there was something amiss with the text selected by the
+    '   operator--maybe the operator just selected a space?
+    
+    ' no matter how we get here, we're going to try a second and more difficult/complicated
+    '   operation, using just the start of the selection
+    ' this is a bit more difficult, because the SelStart pointer relates to
+    '   the plain-text version, not the RTF version; and in the plain text
+    '   the fancy characters are all replaced by question marks
+    
+
+
+    ' isolate the text of the field
+    ' put the text to the right of the insert point into sRight, and
+    '   the text to the left of the insert point into sLeft
+    sLeft$ = Mid(cRichTextBox.Text, 1, lSelStart)
+    sRight$ = Mid(cRichTextBox.Text, lSelStart + 1)
+    
+    'Debug.Print "Text of interest:"
+    'Debug.Print sLeft$ + sRight$
+    
+    ' remove parts of any following fields from the right bit of the record,
+    '   leaving only the right part of the one field
+    lPtr = LocalMarcRecord.Rat(sLeft$, vbLf)
+    If lPtr = 0 Then
+        lPtr = LocalMarcRecord.Rat(sLeft$, vbCr)
+    End If
+    If lPtr > 0 Then ' it better be!
+        sLeft$ = Mid(sLeft$, lPtr + 1)
+    End If
+    ' remove parts of any preceding fields from the left bit of the record, leaving
+    '   only the left part of the one field
+    lPtr = InStr(sRight$, vbCr)
+    If lPtr = 0 Then
+        lPtr = LocalMarcRecord.Rat(sRight$, vbLf)
+    End If
+    If lPtr > 0 Then ' it better be!
+        sRight$ = Mid(sRight$, 1, lPtr - 1)
+    End If
+        
+    ' and here's the whole field
+    sField$ = Trim(sLeft$ + sRight$)
+    
+    ' if now we don't have anything, then we're in serious trouble
+    If Len(sField$) = 0 Then
+
+        Exit Function ' with default return value of zero
+    End If
+    ' isolate the field's tag, and make sure that it's all numeric
+    sTagToFind$ = Mid(sField$, 1, 3)
+    If InStr("0123456789", Mid(sTagToFind$, 1, 1)) = 0 Or InStr("0123456789", Mid(sTagToFind$, 2, 1)) = 0 Or InStr("0123456789", Mid(sTagToFind$, 3, 1)) = 0 Then
+
+        Exit Function ' with default return value of zero
+    End If
+    ' we only move 010 and higher
+    If sTagToFind$ < "010" Then
+        If Not bSearch Or (bSearch And sTagToFind$ <> "001") Then
+
+            Exit Function
+        End If
+    End If
+    
+    ' does the field exist at all?
+    LocalMarcRecord.FldMoveTop
+    If Not LocalMarcRecord.FldFindFirst(sTagToFind$) Then
+
+        Exit Function ' with default return value of zero
+    End If
+    
+    ' if there is only one occurrence of the field, then
+    '    that one occurrence *must* be the one we want
+    If Not LocalMarcRecord.FldFindNext(sTagToFind$) Then
+        ' back up to the field we found just above
+        LocalMarcRecord.FldFindFirst sTagToFind$
+        FindFieldCurrentlyPointedTo = LocalMarcRecord.FldPointer
+
+        Exit Function
+    End If
+    
+    ' OK, so there is more than one field with this tag; we'll have
+    '   to do this the hard way and hope for the best
+    
+    ' the RTF version uses character 135 for the delimiter; translating that
+    '   back to the 'real' delimiter means that we won't have to do the
+    '   translation in the other direction for each field in the record
+    sField$ = LocalMarcRecord.ReplaceCharacters(sField$, Chr(135), LocalMarcRecord.MarcDelimiter)
+
+    LocalMarcRecord.FldMoveTop
+    Do While LocalMarcRecord.FldFindNext(sTagToFind$)
+        sLeft$ = LocalMarcRecord.FldTag + ":" + LocalMarcRecord.FldInd + ": " + LocalMarcRecord.AddSpacesAroundDelimiters(LocalMarcRecord.FldText)
+        ' replace all of the 'special' characters with question marks
+        For lPtr = Len(sLeft$) To 1 Step -1
+            Select Case Asc(Mid(sLeft$, lPtr, 1))
+                Case Is > 191 ' begins 1110 or 1100: first character in multi-byte sequence
+                    sLeft$ = LocalMarcRecord.SafeStuff(sLeft$, lPtr, 1, "?")
+                Case Is > 127 ' second or third character in multi-byte sequence
+                    sLeft$ = LocalMarcRecord.SafeStuff(sLeft$, lPtr, 1, "")
+            End Select
+        Next ' lptr
+
+        If sField$ = sLeft$ Then
+            FindFieldCurrentlyPointedTo = LocalMarcRecord.FldPointer
+            Exit Function
+        End If
+    Loop
+    
+    ' if we fall through to here, we were not able to find the field either way;
+    ' 20100402: changed by David Bucknum from zero to -1:
+    '   so we'll return with the default return value of -1
+
+End Function
+
+Public Function RomanizationAssistanceConvertWholeRecord(ByVal sRecordType$, ByVal iScript%, ByRef LocalMarcRecordObjectAlreadyLoadedWithRecord As Utf8MarcRecordClass, ByRef LocalMarcCharacterObject As Utf8CharClass) As Integer
+
+    Dim sField$, sTag$, sTagToFind$, sIndicators$, s880Indicators$, sNative6$, s8806$, sLeftEnd$, sRecord$
+    Dim sSelText$, sLeft$, sRight$, sRightAfterSelection$, sWholeField$, sWord$, sNewField$, sOldField$
+    Dim sFieldRemainderRight$, sFieldRemainderLeft$, s6$, sOriginalField$, sSfd$, s066$
+    Dim sTagToCopy$, sIndicatorsToCopy$, sFieldToCopy$, sNewFields$, sOldFields$
+    Dim sSubfieldsExcludedUniversally$, sSubfieldsExcludedByTag$, sSubfield6Code$
+    Dim sRLM$, sLRE$, sPDF$
+    
+    Dim iRc%, iRc2%, iRepeat%, iNext6%, iRomanizationStyle%, iDirection%
+    
+    Dim lPtr As Long, lSelLength As Long, lSelStart As Long, lStart As Long
+    Dim lFldPointer As Long, lEnd As Long
+        
+    Dim bFound As Boolean, bSkipTagTest As Boolean
+    Dim bCreateEmptyFields As Boolean, bCreateEmpty880s As Boolean
+    Dim bLcPattern As Boolean
+    
+    Const sLineEnd = "\par"
+    Const iLineEndLen = 5
+            
+
+    If gblaRomanizationTable(iScript%).DoNotUse880Field Then
+
+        RomanizationAssistanceConvertWholeRecord = ROMANIZATIONRESULT_880NotAllowed%
+        Exit Function
+    End If
+    
+    If LocalMarcRecordObjectAlreadyLoadedWithRecord.FldFindFirst("880") Then
+
+        RomanizationAssistanceConvertWholeRecord = ROMANIZATIONRESULT_880AlreadyPresent%
+        Exit Function
+    End If
+    
+    ' if the record contains *any* vernacular, then we assume that we're going
+    '   from vernacular to roman; otherwise, we assume that we're going from
+    '   roman to vernacular
+    ' we need to know the direction before we meet up the first field during
+    '   translation, so we know which set of tags to apply
+    With LocalMarcRecordObjectAlreadyLoadedWithRecord
+        iDirection% = ROMANIZATIONDIRECTION_Roman2Vernacular%
+        .FldMoveTop
+        Do While .FldMoveNext
+            '20101213: Bucknum changed to "V2RFieldsIncluded" check to fix R2V/V2R logic below
+            'If .FldTag > "009" Then
+            If InStr(gblaRomanizationTable(iScript%).V2RFieldsIncluded, .FldTag) > 0 Then
+                Do
+                    'Debug.Print "Evaluating " + .FldTag + ":" + .SfdCode + ":" + .SfdText
+                    If gblaRomanizationTable(iScript%).V2RCreateEmptyFields = True And _
+                        .Utf8TextContainsOnlyMarc8Characters(.SfdText) = False Then
+                        iDirection% = ROMANIZATIONDIRECTION_Vernacular2Roman%
+                        GoTo RomanAssist_HaveDirection
+                    ElseIf EvaluateFirstCharacter(.SfdText, iScript%, LocalMarcCharacterObject) = ROMANIZATIONDIRECTION_Vernacular2Roman% Then
+                        iDirection% = ROMANIZATIONDIRECTION_Vernacular2Roman%
+                        GoTo RomanAssist_HaveDirection
+                    End If
+                    If Not .SfdMoveNext Then
+                        Exit Do
+                    End If
+                Loop
+            End If
+        Loop
+RomanAssist_HaveDirection:
+    End With
+
+
+    ' 20070227: if we're going from romanized to vernacular, then
+    '   figure out if we're going to try to do the work, or just
+    '   create dummy fields for the operator to complete
+    If iDirection% = ROMANIZATIONDIRECTION_Roman2Vernacular% Then
+        If gblaRomanizationTable(iScript%).R2VCreateEmpty880s Then
+            bCreateEmpty880s = True
+            ' 20070425: pick up a script code if it's been defined--we'll include this
+            '   in $6 of "empty" 880 fields, and also in 066
+            ' 20070830: LC addition: if there is no such code, pick up
+            '   a transmogrification of the langauge code instead; area reorganized
+            sSubfield6Code$ = gblaRomanizationTable(iScript%).R2VSubfield6Code
+            If LenB(sSubfield6Code$) = 0 Then
+                sSubfield6Code$ = Language2ScriptCode(LocalMarcRecordObjectAlreadyLoadedWithRecord.Get008Value(35, 3))
+            End If
+            If LenB(sSubfield6Code$) > 0 Then
+                s066$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "c" + sSubfield6Code$
+                If sSubfield6Code$ = CHARACTERSET_CODES_FOR_880_HebrewAsG0$ Or _
+                   sSubfield6Code$ = CHARACTERSET_CODES_FOR_880_BasicArabicAsG0$ Then
+                    ' add R2L orientation code
+                    sSubfield6Code$ = sSubfield6Code$ & "/r"
+                End If
+                ' add "/" prefix
+                sSubfield6Code$ = "/" + sSubfield6Code$
+            End If
+        End If
+        ' 20070710: set a variable for the MarcRightToLeftMarker
+        '   LC wants a RTL marker before and after each delimiter,
+        '   EXCEPT immediately following the $6 code itself
+        If gblaRomanizationTable(iScript%).R2VIncludeFormattingCharactersLcPattern Or _
+           InStr(sSubfield6Code$, "/r") > 0 Then
+            ' set IncludeFormattingCharactersLcPattern = True to insert UFCs
+            ' 20070830: Bucknum code forces value of this here; but we think
+            '   this should come from the configuration file
+            ' instead, we're going to set directly what DB was using this
+            '   as a proxy for
+            'gblaRomanizationTable(iScript%).R2VIncludeFormattingCharactersLcPattern = True
+            bLcPattern = True
+            With LocalMarcRecordObjectAlreadyLoadedWithRecord
+                sRLM$ = .MarcRightToLeftMarker
+                sLRE$ = .MarcLeftToRightEmbedding
+                sPDF$ = .MarcPopDirectionalFormatting
+            End With
+        Else
+            ' set IncludeFormattingCharactersLcPattern = False to not insert UFCs
+            ' 20070830: Bucknum code forces value of this here; but we think
+            '   this should come from the configuration file
+            ' instead, we're going to leave sRLM at its ground state of null,
+            '   which seems to be the point of all of this, anyway
+            'gblaRomanizationTable(iScript%).R2VIncludeFormattingCharactersLcPattern = False
+            bLcPattern = False
+        End If
+    Else
+        If gblaRomanizationTable(iScript%).V2RCreateEmptyFields = True Then
+            bCreateEmptyFields = True
+        End If
+    End If
+    
+    ' go through the record one field at a time
+    ' if the field contains vernacular data, copy the field to 880 and create the
+    '   parallel normal field with romanized vernacular data
+    ' if the field contains no vernacular data, copy the field to 880, converting
+    '   romanized text to vernacular as you go
+    LocalMarcRecordObjectAlreadyLoadedWithRecord.FldMoveTop
+    Do While LocalMarcRecordObjectAlreadyLoadedWithRecord.FldMoveNext
+        DoEvents
+        If Not LocalMarcRecordObjectAlreadyLoadedWithRecord.FldDeleted Then
+
+            If iDirection% = ROMANIZATIONDIRECTION_Vernacular2Roman Then
+                If InStr(gblaRomanizationTable(iScript%).V2RFieldsIncluded, LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag) = 0 Then
+                    'Debug.Print LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + " field excluded V2$"
+
+                    GoTo RomanAssist_WholeRecordNextField
+                End If
+                sSubfieldsExcludedUniversally$ = gblaRomanizationTable(iScript%).V2RSubfieldsAlwaysExcluded
+                sSubfieldsExcludedByTag$ = gblaRomanizationTable(iScript%).V2ROtherSubfieldsExcludedByTag
+            Else
+                If InStr(gblaRomanizationTable(iScript%).R2VFieldsIncluded, LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag) = 0 Then
+
+                    GoTo RomanAssist_WholeRecordNextField
+                End If
+                sSubfieldsExcludedUniversally$ = gblaRomanizationTable(iScript%).R2VSubfieldsAlwaysExcluded
+                sSubfieldsExcludedByTag$ = gblaRomanizationTable(iScript%).R2VOtherSubfieldsExcludedByTag
+            End If
+            sTag$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag
+            sNewField$ = ""
+            sOldField$ = ""
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdMoveFirst
+            Do
+                ' 20070710: add RLMs before and after the delimiter/subfield codes,
+                '   as appropriate, but *only* if the Right2LeftMark variable is set
+                ' 20070713: add a LeftToRightEmbedding character (LRE) only
+                '   before the 880 $6 260-xx $c [dates] - a PDF is added below
+                ' 20121121: added 264 (RDA) to logic
+                If bLcPattern Then
+                    sNewField$ = sNewField$ + sRLM$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode + sRLM$
+                    If sTag$ Like "26[04]" And LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode = "c" Then
+                        sNewField$ = sNewField$ + sLRE$
+                    End If
+                Else
+                    sNewField$ = sNewField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode
+                End If
+                sOldField$ = sOldField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText
+                If bCreateEmpty880s Or bCreateEmptyFields Then
+' added 20070308 by David Bucknum
+#If True Then
+                    ' replacement proposed by Bucknum
+                    ' include this subfield, but change it to a plus sign
+                    '   if the 260 $c contains an ending period, add it for PDF processing
+                    ' 20121121: added 264 (RDA) to logic
+                    If sTag$ Like "26[04]" And LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode = "c" And Right(LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, 1) = "." Then
+                        sNewField$ = sNewField$ + "+."
+                    Else
+                        sNewField$ = sNewField$ + "+"
+                    End If
+#Else
+                    ' include this subfield without attampting to change it
+                    sNewField$ = sNewField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText
+#End If
+                ElseIf InStr(sSubfieldsExcludedUniversally$, LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode) > 0 Then
+                    ' include this subfield attempting to change it
+                    sNewField$ = sNewField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText
+                ElseIf InStr(sSubfieldsExcludedByTag$, LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + "/" + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode) > 0 Then
+                    ' include this subfield without attampting to change it
+                    sNewField$ = sNewField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText
+                Else ' we attempt to change this subfield
+
+                    Select Case iDirection% ' EvaluateFirstCharacter(LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, iScript%, LocalMarcCharacterObject)
+                        Case ROMANIZATIONDIRECTION_Vernacular2Roman%, ROMANIZATIONDIRECTION_Roman2Vernacular%
+                            If LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode = "a" Then
+                                sSfd$ = ReRomanizeText(sRecordType$, sTag$, LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject, iDirection%)
+                                'Debug.Print "Subfield changed: >" + sSfd$ + "<"
+                                If sSfd$ <> LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText Then
+                                    sNewField$ = sNewField$ + ReRomanizeText(sRecordType$, sTag$, LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject, iDirection%, LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode)
+                                Else
+                                    sNewField$ = sNewField$ + ReRomanizeText(sRecordType$, sTag$, LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject, iDirection%, LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode)
+                                End If
+                            Else
+                                 sNewField$ = sNewField$ + ReRomanizeText(sRecordType$, sTag$, LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText, iScript%, LocalMarcRecordObjectAlreadyLoadedWithRecord, LocalMarcCharacterObject, iDirection%, LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode)
+                            End If
+                        Case Else
+                            sNewField$ = sNewField$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdText
+                    End Select
+                End If
+                ' 20070713: add a POPDirectionalFormatting character (PDF) only
+                '   at the end of the 880 $6 260-xx $c [dates] - an LRE is added above
+                ' 20121121: added 264 (RDA) to logic
+                If bLcPattern Then
+                    If sTag$ Like "26[04]" And LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdCode = "c" Then
+                        ' if the subfield ends with a period, place the period after the PDF
+                        If Right(sNewField$, 1) = "." Then
+                            sNewField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.SafeStuff(sNewField$, InStrRev(sNewField$, "."), 1, sPDF$ + ".")
+                        Else
+                            sNewField$ = sNewField$ + sPDF$
+                        End If
+                    End If
+                End If
+                If Not LocalMarcRecordObjectAlreadyLoadedWithRecord.SfdMoveNext Then
+                    Exit Do
+                End If
+            Loop
+
+
+            sIndicators$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.FldInd
+            ' change 880 $6 6xx-xx 2nd indicator to "4" (source not specified)
+            If sTag$ >= 600 And sTag$ <= 651 Then
+                s880Indicators$ = Mid$(sIndicators$, 1, 1) & "4"
+            Else
+                s880Indicators$ = sIndicators$
+            End If
+            
+            If bCreateEmpty880s Then
+                ' we're only creating an "empty" 880 field
+                iNext6% = iNext6% + 1
+                If Len(sNewFields$) > 0 Then
+                    sNewFields$ = sNewFields$ + vbLf
+                    sOldFields$ = sOldFields$ + vbLf
+                End If
+                ' 20070425 script code added if available (only available if roman-to-vernacular)
+#If True Then
+                ' changed 20070308 by David Bucknum
+                ' use this line if you want a truly empty 880 field *OR* fields with "+" as subfield text
+                If bLcPattern Then
+                    sNewFields$ = sNewFields$ + "880" + s880Indicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + "-" + Right("00" + Trim(str(iNext6%)), 2) + sSubfield6Code$ + sRLM$ + sNewField$
+                Else
+                    sNewFields$ = sNewFields$ + "880" + s880Indicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + "-" + Right("00" + Trim(str(iNext6%)), 2) + sSubfield6Code$ + sNewField$
+                End If
+#Else
+                ' use this line if you want the 880 field to start out with text as given in the original field
+                If bLcPattern Then
+                    sNewFields$ = sNewFields$ + "880" + s880Indicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + "-" + Right("00" + Trim(str(iNext6%)), 2) + sSubfield6Code$ + sRLM$ + sOldField$
+                Else
+                    sNewFields$ = sNewFields$ + "880" + s880Indicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + "-" + Right("00" + Trim(str(iNext6%)), 2) + sSubfield6Code$ + sOldField$
+                End If
+#End If
+                sOldFields$ = sOldFields$ + Trim(str(LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer)) + vbTab + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + "880-" + Right("00" + Trim(str(iNext6%)), 2) + sOldField$
+            ElseIf bCreateEmptyFields Then
+                ' we're only creating an "empty" romanized field
+                iNext6% = iNext6% + 1
+                If Len(sNewFields$) > 0 Then
+                    sNewFields$ = sNewFields$ + vbLf
+                    sOldFields$ = sOldFields$ + vbLf
+                End If
+#If True Then
+                ' changed 20090524 by David Bucknum
+                ' use this line if you want a truly empty romanized field *OR* fields with "+" as subfield text
+                sNewFields$ = sNewFields$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + sIndicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6880-" + Right("00" + Trim(str(iNext6%)), 2) + sNewField$
+#Else
+                ' use this line if you want the 880 field to start out with text as given in the original field
+                sNewFields$ = sNewFields$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + sIndicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6880-" + Right("00" + Trim(str(iNext6%)), 2) + sOldField$
+#End If
+                sOldFields$ = sOldFields$ + Trim(str(LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer)) + vbTab + s880Indicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + "-" + Right("00" + Trim(str(iNext6%)), 2) + sOldField$
+            Else
+                If sNewField$ <> sOldField$ Then ' we changed *something*!
+                    iNext6% = iNext6% + 1
+                    If Len(sNewFields$) > 0 Then
+                        sNewFields$ = sNewFields$ + vbLf
+                        sOldFields$ = sOldFields$ + vbLf
+                    End If
+                    If iDirection% = ROMANIZATIONDIRECTION_Vernacular2Roman% Then
+                        sOldFields$ = sOldFields$ + Trim(str(LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer)) + vbTab + s880Indicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + "-" + Right("00" + Trim(str(iNext6%)), 2) + sOldField$
+                        sNewFields$ = sNewFields$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + sIndicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6880-" + Right("00" + Trim(str(iNext6%)), 2) + sNewField$
+                    Else
+                        sNewFields$ = sNewFields$ + "880" + s880Indicators$ + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + LocalMarcRecordObjectAlreadyLoadedWithRecord.FldTag + "-" + Right("00" + Trim(str(iNext6%)), 2) + sNewField$
+                        sOldFields$ = sOldFields$ + Trim(str(LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer)) + vbTab + LocalMarcRecordObjectAlreadyLoadedWithRecord.MarcDelimiter + "6" + "880-" + Right("00" + Trim(str(iNext6%)), 2) + sOldField$
+                    End If
+                End If
+            End If
+        End If
+RomanAssist_WholeRecordNextField:
+    Loop
+    Do While Len(sOldFields$) > 0
+        DoEvents
+        GetNextPiece sOldFields$, sField$, vbLf
+        If iDirection% = ROMANIZATIONDIRECTION_Vernacular2Roman% Then
+            GetNextPiece sField$, sTag$, vbTab
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = Val(sTag$)
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldDelete
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldAdd "880", Mid(sField$, 1, 2), Mid(sField$, 3)
+        Else
+            GetNextPiece sField$, sTag$, vbTab
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldPointer = Val(sTag$)
+            ' 20100809 Bucknum added: remove temporary VowelMarker character before export
+            If LenB(gblaRomanizationTable(iScript%).R2VVowelMarker) > 0 Then
+                sField$ = LocalMarcRecordObjectAlreadyLoadedWithRecord.ReplaceCharacters(sField$, gblaRomanizationTable(iScript%).R2VVowelMarker)
+            End If
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldText = sField$
+        End If
+    Loop
+    Do While Len(sNewFields$) > 0
+        GetNextPiece sNewFields$, sField$, vbLf
+        If iDirection% = ROMANIZATIONDIRECTION_Vernacular2Roman% Then
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldAdd Mid(sField$, 1, 3), Mid(sField$, 4, 2), LocalMarcRecordObjectAlreadyLoadedWithRecord.UCaseFirstWord(Mid(sField$, 6))
+        Else
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldAdd Mid(sField$, 1, 3), Mid(sField$, 4, 2), Mid(sField$, 6)
+        End If
+    Loop
+    
+    ' 20070425 build an 066 if the script identification code is available
+    '   only possible if building empty 880s and if roman-to-vernacular
+    If bCreateEmpty880s And LenB(s066$) > 0 Then
+        If Not LocalMarcRecordObjectAlreadyLoadedWithRecord.FldFindFirst("066") Then
+            LocalMarcRecordObjectAlreadyLoadedWithRecord.FldAdd "066", "  ", s066$
+        End If
+    End If
+        
+    
+End Function
+
+Public Sub ReRomanizeAdjustNonfilingIndicators(iScript%, ByVal sNonfilingTagString$, ByVal lPointerToOriginalField As Long, ByVal lPointerToNewField As Long, ByRef LocalMarcRecord As Utf8MarcRecordClass, ByRef LocalCharacterObject As Utf8CharClass)
+
+    Dim iNonfiling%, iNonfilingIndicator%, iRc%, iLen%
+    
+    Dim sOriginal$
+    
+    
+
+    With LocalMarcRecord
+
+        .FldPointer = lPointerToOriginalField
+
+        If .SfdFindFirst("a") Then
+            If .FldTag = "880" Then
+                If .SfdFindFirst("6") Then
+                    iRc% = InStr(sNonfilingTagString$, Mid(.SfdText, 1, 3))
+                End If
+                .SfdFindFirst "a"
+            Else
+                iRc% = InStr(sNonfilingTagString$, .FldTag)
+            End If
+
+            If iRc% > 0 Then
+                iNonfiling% = Val(Mid(sNonfilingTagString$, iRc% + 4, 1))
+
+                If iNonfiling% > 0 Then
+                    ' we're going to ignore nonfiling indicator values of 1,
+                    '   because they almost certainly refer to an error (such as
+                    '   skipping an opening quotation mark)
+                    iNonfilingIndicator% = Val(Mid(.FldInd, iNonfiling%, 1))
+
+                    If iNonfilingIndicator% > 0 Then
+                        sOriginal$ = .SafeMid(.SfdText, 1, iNonfilingIndicator%)
+
+                        .FldPointer = lPointerToNewField
+
+                        If .SfdFindFirst("a") Then
+                            If Mid(.SfdText, 1, Len(sOriginal$)) <> sOriginal$ Then
+                                ' the beginning of subfield $a in the modified field is
+                                '   not same as the beginning of subfield $a in the original
+                                '   field: therefore, the current operation changed the value
+                                '   of subfield $a, and we need to address the problem of the
+                                '   initial articla
+                                ' at this point we have to know whether the conversion was
+                                '   vernacular-to-script or script-to-vernacular
+                                If .FldTag = "880" Then
+                                    ' the tag of the new field is 880; therefore, the conversion
+                                    '   was from romanized-to-vernacular; sOriginal$ contains the
+                                    '   romanized form of the critical text
+                                    sOriginal$ = ReRomanizeText("B", "500", sOriginal$, iScript%, LocalMarcRecord, LocalCharacterObject, ROMANIZATIONDIRECTION_Roman2Vernacular%)
+                                Else
+                                    ' the tag of the new field is NOT 880; therefore, the conversion
+                                    '   was from vernacular-to-romanized; sOriginal$ contains the
+                                    '   romanized form of the critical text
+                                    sOriginal$ = ReRomanizeText("B", "500", sOriginal$, iScript%, LocalMarcRecord, LocalCharacterObject, ROMANIZATIONDIRECTION_Vernacular2Roman%)
+                                End If
+
+                                If Mid(.SfdText, 1, Len(sOriginal$)) = sOriginal$ Then
+                                    iLen% = .SafeLen(sOriginal$)
+                                    If iLen% < 9 Then
+                                        'Debug.Print ">" + .FldInd + "< " + str(iNonfiling%) + " " + str(iLen%)
+                                        .FldInd = .SafeStuff(.FldInd, iNonfiling%, 1, Trim(str(iLen%)))
+                                        'Debug.Print "After change: >" + .FldInd + "<"
+                                    End If
+                                End If
+                            End If
+                        End If
+                    End If
+                End If
+            End If
+        End If
+    End With
+    
+End Sub
+
+Public Function Language2ScriptCode(ByVal sLanguageCode$) As String
+
+    Select Case sLanguageCode$
+'        Case ""
+'            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_BasicAsG0$
+        Case "heb", "yid"
+            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_HebrewAsG0$
+        Case "bel", "mac", "rus", "scc", "ukr"
+            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_BasicCyrillicAsG0$
+        Case "ara", "per", "urd"
+            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_BasicArabicAsG0$
+        Case "gre"
+            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_GreekAsG0$
+        Case "chi", "jap", "kor"
+            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_CJKAsG0$
+' don't know which, if any, languages belong here by default:
+'        Case ""
+'            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_ExtendedCyrillicAsG1$
+'        Case ""
+'            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_ExtendedArabicAsG1$
+'        Case ""
+'            Language2ScriptCode = CHARACTERSET_CODES_FOR_880_ExtendedLatinAsG1$
+        Case Else
+            Language2ScriptCode = ""
+    End Select
+
+End Function
+
+Public Function ReSequencePairedFields(ByRef LocalMarcRecordObjectAlreadyLoadedWithRecord As Utf8MarcRecordClass)
+
+    Dim iCtr%
+    Dim lPtr&
+    Dim sSfdText$
+    Dim bMatchFound As Boolean
+    
+    gbliReSequenceTableLast% = 0
+
+    With LocalMarcRecordObjectAlreadyLoadedWithRecord
+        ' loop through record to find non-880s with subfield $6
+        .FldMoveTop
+        Do While .FldMoveNext
+            ' create array of non-880 fields with subfield $6
+            ' with new consecutive sequence numbers
+            If .FldTag <> "880" Then
+                If .SfdFindFirst("6") = True Then
+                    If Mid$(.SfdText, 5, 2) <> "00" Then
+                        gbliReSequenceTableLast% = gbliReSequenceTableLast% + 1
+                        ReDim Preserve gblaReSequenceTable(gbliReSequenceTableLast%)
+                        gblaReSequenceTable(gbliReSequenceTableLast%).Tag = .FldTag
+                        gblaReSequenceTable(gbliReSequenceTableLast%).Field = .FldText
+                        gblaReSequenceTable(gbliReSequenceTableLast%).Sequence = gbliReSequenceTableLast%
+                    ' "00" (non-paired) should not appear in a non-880 subfield $6
+                    ' but we'll not delete it for now
+'                   Else: .SfdDelete
+                    End If
+                End If
+            End If
+        Loop
+
+        ' cannot resequence, if no non-880 subfield $6s are found
+        If gbliReSequenceTableLast% = 0 Then Exit Function
+        
+        ' loop through the record again to match 880s with non-880s
+        .FldMoveTop
+        Do While .FldMoveNext
+            ' add paired and non-paired 880s to the array
+            If .FldTag = "880" Then
+                If .SfdFindFirst("6") = True Then
+                    ' make sure 880 $6 6xx-xx 2nd indicators are set to "4" (source not specified)
+                    If Mid$(.SfdText, 1, 3) >= 600 And Mid$(.SfdText, 1, 3) <= 651 Then
+                        .FldInd2 = "4"
+                    End If
+                    If Mid$(.SfdText, 5, 2) <> "00" Then
+                        bMatchFound = False
+                        For iCtr% = 1 To gbliReSequenceTableLast%
+                            ' first make sure the 880 sequence number is zero
+                            If gblaReSequenceTable(iCtr%).Sequence880 = 0 Then
+                                ' if there is a match, pair the sequence numbers
+                                ' add the link tag and field text for comparison later
+                                If Mid$(.SfdText, 1, 3) = gblaReSequenceTable(iCtr%).Tag Then
+                                    gblaReSequenceTable(iCtr%).LinkTag = gblaReSequenceTable(iCtr%).Tag
+                                    gblaReSequenceTable(iCtr%).Field880 = .FldText
+                                    gblaReSequenceTable(iCtr%).Sequence880 = gblaReSequenceTable(iCtr%).Sequence
+                                    bMatchFound = True
+                                    Exit For
+                                End If
+                            End If
+                        Next ' iCtr%
+                    End If
+                    ' add non-paired 880s to the array with a "00" sequence number
+                    If bMatchFound = False Or Mid$(.SfdText, 5, 2) = "00" Then
+                        gbliReSequenceTableLast% = gbliReSequenceTableLast% + 1
+                        ReDim Preserve gblaReSequenceTable(gbliReSequenceTableLast%)
+                        gblaReSequenceTable(gbliReSequenceTableLast%).Tag = .FldTag
+                        gblaReSequenceTable(gbliReSequenceTableLast%).Field = .FldText
+                        gblaReSequenceTable(gbliReSequenceTableLast%).Sequence = 0
+                        gblaReSequenceTable(gbliReSequenceTableLast%).Sequence880 = 0
+                    End If
+                End If
+            End If
+        Loop
+        
+        ' loop through record again to resequence the paired fields
+        .FldMoveTop
+        Do While .FldMoveNext
+            ' get field pointer
+            lPtr& = .FldPointer
+            If Val(.FldTag) > 99 Then
+                If .SfdFindFirst("6") = True Then
+                    ' loop through the field/sequence array
+                    For iCtr% = 1 To gbliReSequenceTableLast%
+                        ' 20080826: compare the tags and field data, if matched,
+                        '  adjust the sequence numbers in the field, and
+                        '  delete the field data to prevent a rematch
+                        ' non-880s
+                        If .FldTag = gblaReSequenceTable(iCtr%).Tag And _
+                           .FldText = gblaReSequenceTable(iCtr%).Field Then
+                            .SfdText = .SafeStuff(.SfdText, 5, 2, Right("00" & CStr(gblaReSequenceTable(iCtr%).Sequence), 2))
+                            ' change field text to avoid re-matching an "empty" field (i.e. with "+" subfields)
+                            gblaReSequenceTable(iCtr%).Field = ""
+                            Exit For
+                        ' 880s
+                        ElseIf Mid$(.SfdText, 1, 3) = gblaReSequenceTable(iCtr%).LinkTag And _
+                           .FldText = gblaReSequenceTable(iCtr%).Field880 Then
+                            .SfdText = .SafeStuff(.SfdText, 5, 2, Right("00" & CStr(gblaReSequenceTable(iCtr%).Sequence880), 2))
+                            ' change field text to avoid re-matching an "empty" 880 (i.e. with "+" subfields)
+                            gblaReSequenceTable(iCtr%).Field880 = ""
+                            Exit For
+                        End If
+                    Next ' iCtr%
+                End If
+            End If
+            ' reset field pointer
+            .FldPointer = lPtr&
+        Loop
+        
+    End With
+    
+    ' clear the array from memory
+    Erase gblaReSequenceTable
+
+End Function
+
+Public Function AddCharSetCodes2Utf8Record(ByRef LocalMarcRecordObjectAlreadyLoadedWithRecord As Utf8MarcRecordClass, ByVal iScript%)
+
+    Dim iPtr%, iCtr%, iNonfiling%, iIndicator%
+    Dim bChanged As Boolean, bError As Boolean
+    Dim sTag$, sIndicators$, sField$, sNonfiling$, sChar$
+    Dim sCharacterSetsPresent$, s066$, sSfd6$, sPiece$
+    Dim bLcPattern As Boolean
+    
+    If gblaRomanizationTable(iScript%).R2VIncludeFormattingCharactersLcPattern Then bLcPattern = True
+    
+    With LocalMarcRecordObjectAlreadyLoadedWithRecord
+
+        .FldMoveTop
+        Do While .FldMoveNext
+            iPtr% = .FldPointer
+            ' remove any existing 066 fields, but *not* in records with "empty" 880s
+            If .FldTag = "066" And gblaRomanizationTable(iScript%).R2VCreateEmpty880s = False Then .FldDelete
+            ' get the $6, including script codes, using a fake Utf82Marc translation
+            If .FldTag = "880" Then
+                .FldLoadInfo sTag$, sIndicators$, sField$
+                .TranslateUtf82MarcOneField sCharacterSetsPresent$, sTag$, sField$, bChanged, bError
+                If bChanged Then
+                    If .SfdFindFirst("6") = True And _
+                       .ExtractSubfield(sField$, "6", sSfd6$) > 0 Then
+                        ' 20070710: add RLM to the end of subfield $6 in "empty" fields for R2L scripts
+                        If bLcPattern Or InStr(sSfd6$, "/r") > 0 Then
+                            sSfd6$ = sSfd6$ & .MarcRightToLeftMarker
+                        End If
+                        .SfdChange "6", sSfd6$
+                    End If
+                End If
+                ' 20070710: check for and add the RLMs in the 880 fields for
+                ' the R2L scripts, if they have not been inserted elsewhere
+                If bLcPattern Or InStr(sSfd6$, "/r") > 0 Then
+                    .FldText = .TranslateMarc2Utf8OneFieldLcPattern("880", .FldText)
+                    ' remove any multiple UFCs from the field
+                    .FldText = .RemoveRepeatedCharacters(.FldText, .MarcRightToLeftMarker)
+                    .FldText = .RemoveRepeatedCharacters(.FldText, .MarcLeftToRightEmbedding)
+                    .FldText = .RemoveRepeatedCharacters(.FldText, .MarcPopDirectionalFormatting)
+                End If
+            End If
+            .FldPointer = iPtr%
+        Loop
+
+        ' convert the string of codes representing character sets present in the record into
+        '   an 066 field, and add it to or change it in the record, but *not* in records with "empty" 880s
+        ' remove multiple spaces from the string
+        sCharacterSetsPresent$ = .RemoveRepeatedCharacters(Trim(sCharacterSetsPresent$), " ")
+        s066$ = .TranslateUtf82MarcCharacterSetString(sCharacterSetsPresent$, .MarcDelimiter + "c")
+        If Len(s066$) > 0 Then
+            If Not .FldFindFirst("066") Or gblaRomanizationTable(iScript%).R2VCreateEmpty880s = False Then
+                .FldAddGeneric "066", "  ", s066$, 3
+            ElseIf .FldText <> s066$ Then
+                .FldChange "066", "  ", s066$
+            End If
+        End If
+        
+    End With
+    
+End Function
+
+Public Function RomanizeConvertDecimalChars(ByVal sIn$, ByRef LocalMarcRecordObject As Utf8MarcRecordClass, ByRef LocalCharacterObject As Utf8CharClass) As String
+
+    ' convert "&#\d{4,5}" numeric character references to the equivalent, leaving other stuff as you find it
+    Dim lPtr As Long
+    
+    Dim sLeader$, sOriginal$, sHexChar$
+    Dim iDigits%
+    
+    Dim bShow As Boolean
+       
+    'If InStr(sIn$, "&#") > 0 Then
+    '    bShow = True
+    '    sOriginal$ = sIn$
+    'End If
+    
+    sLeader$ = "&#"
+    
+    Do
+        lPtr = InStr(sIn$, sLeader$)
+        Do While lPtr > 0
+            ' allow conversion of up to 5-digit character references
+            iDigits% = Len(CStr(Val(Mid$(sIn$, lPtr + 2, 5))))
+            sHexChar$ = Hex$(Mid$(sIn$, lPtr + 2, iDigits%))
+            LocalCharacterObject.UcsHex = Right$(String$(4 - Len(sHexChar$), "0") & sHexChar$, 4)
+            sIn$ = LocalMarcRecordObject.SafeStuff(sIn$, lPtr, iDigits% + 2, LocalCharacterObject.Utf8Char)
+            lPtr = InStr(sIn$, sLeader$)
+        Loop
+        Select Case sLeader$
+            Case "&#"
+                ' scossu: added a third backslash because 2 backslashes mess up syntax coloring in Vim.
+                sLeader$ = "\\\"
+            ' scossu: added a third backslash because 2 backslashes mess up syntax coloring in Vim.
+            Case "\\\"
+                Exit Do
+        End Select
+    Loop
+    
+    RomanizeConvertDecimalChars = sIn$
+    
+End Function
+
+Public Function FindScriptByKeyPress(ByRef c As Control, ByRef KeyAscii As Integer)
+    
+    Dim cb As Long
+    Dim FindString As String
+   
+    If KeyAscii < 32 Or KeyAscii > 127 Then Exit Function
+   
+    If c.SelLength = 0 Then
+        FindString = c.Text & Chr$(KeyAscii)
+    Else
+        FindString = Left$(c.Text, c.SelStart) & Chr$(KeyAscii)
+    End If
+   
+    cb = SendMessage(c.hWnd, CB_FINDSTRING, -1, ByVal FindString)
+   
+    If cb <> CB_ERR Then
+        c.ListIndex = cb
+        c.SelStart = Len(FindString)
+        c.SelLength = Len(c.Text) - c.SelStart
+    End If
+    
+    KeyAscii = 0
+    
+End Function
+
+Public Function IsFontInstalled(FontName As String) As Boolean
+
+    ' Returns true in function name
+    ' if parameter font name exists
+    
+    Dim oFont As New StdFont
+    
+On Error Resume Next
+    
+    IsFontInstalled = False
+    
+    If LenB(FontName) > 0 Then
+        With oFont
+            .Name = FontName
+            If StrComp(FontName, .Name, vbTextCompare) = 0 Then IsFontInstalled = True
+        End With
+    End If
+
+    Set oFont = Nothing
+    
+End Function
+
+Public Function CreateRomanizationScriptList(ByRef sConfigurationFilePath$, ByRef sScripts2Load As String)
+
+    Dim sMasterFile$, sFile$
+    Dim sScripts2LoadList$()
+    Dim iCtr%, iPtr%
+    Dim bLoadAllScripts As Boolean
+
+    sMasterFile$ = sConfigurationFilePath$ + "RomanizationMaster.cfg"
+
+    If sScripts2Load$ = vbNullString Then
+        bLoadAllScripts = True
+    Else
+        sScripts2LoadList$() = Split(sScripts2Load$)
+    End If
+    
+    gbliRomanizationScriptLast% = 0
+    gbliRomanizationTablesBytes# = 0
+
+    Do
+        iCtr% = gbliRomanizationScriptLast% + 1
+        sFile$ = ReadIniFileOrNothing(sMasterFile$, "Files", Trim(str(iCtr%)), 250)
+        
+        If LenB(sFile$) = 0 Then Exit Do
+        
+        gbliRomanizationScriptLast% = gbliRomanizationScriptLast% + 1
+        ReDim Preserve gblaRomanizationScript(gbliRomanizationScriptLast%)
+        
+        If InStr(sFile$, "\") = 0 Then
+            If LenB(Dir$(sConfigurationFilePath$ + sFile$)) Then
+                gblaRomanizationScript(gbliRomanizationScriptLast%).Name = ReadIniFileOrNothing(sConfigurationFilePath$ + sFile$, "General", "Name", 100)
+                gblaRomanizationScript(gbliRomanizationScriptLast%).FileSize = FileLen(sConfigurationFilePath$ + sFile$)
+            End If
+        Else
+            If LenB(Dir$(sFile$)) Then
+                gblaRomanizationScript(gbliRomanizationScriptLast%).Name = ReadIniFileOrNothing(sFile$, "General", "Name", 100)
+                gblaRomanizationScript(gbliRomanizationScriptLast%).FileSize = FileLen(sFile$)
+            End If
+        End If
+        If bLoadAllScripts Then
+            gblaRomanizationScript(gbliRomanizationScriptLast%).LoadScript = True
+            gbliRomanizationTablesBytes# = gbliRomanizationTablesBytes# + gblaRomanizationScript(gbliRomanizationScriptLast%).FileSize
+        Else
+            gblaRomanizationScript(gbliRomanizationScriptLast%).LoadScript = False
+            For iPtr% = 0 To UBound(sScripts2LoadList$)
+                If CInt(sScripts2LoadList$(iPtr%)) = gbliRomanizationScriptLast% Then
+                    gblaRomanizationScript(gbliRomanizationScriptLast%).LoadScript = True
+                    gbliRomanizationTablesBytes# = gbliRomanizationTablesBytes# + gblaRomanizationScript(gbliRomanizationScriptLast%).FileSize
+                End If
+            Next ' iPtr%
+        End If
+    Loop
+    
+End Function
+
+Public Sub LoadRomanizationTablesProgress(l As Long, ProgressBarCtrl As Control)
+
+    If ProgressBarCtrl.Value < (ProgressBarCtrl.Max - l) Then
+        ProgressBarCtrl.Value = ProgressBarCtrl.Value + l
+    End If
+        
+End Sub