Tekkon // (v1.5.0) AlvinLiu parser support.

Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Constants.swift

@@ -542,9 +542,9 @@ public enum Tekkon {
   /// 在這裡將二十六個字母寫全，也只是為了方便做 validity check。
   /// 這裡提前對複音按鍵做處理，然後再用程式判斷介母類型、據此判斷是否需要做複音切換。
   static let mapDachenCP26StaticKeys: [String: String] = [
-    "a": "ㄇ", "b": "ㄖ", "c": "ㄏ", "d": "ㄎ", "e": "ㄍ", "f": "ㄑ", "g": "ㄕ", "h": "ㄘ", "i": "ㄛ", "j": "ㄨ", "k": "ㄜ",
+    "a": "ㄇ", "b": "ㄖ", "c": "ㄏ", "d": "ㄎ", "e": "ㄍ", "f": "ㄑ", "g": "ㄕ", "h": "ㄘ", "i": "ㄞ", "j": "ㄨ", "k": "ㄜ",
-    "l": "ㄠ", "m": "ㄩ", "n": "ㄙ", "o": "ㄟ", "p": "ㄣ", "q": "ㄆ", "r": "ㄐ", "s": "ㄋ", "t": "ㄔ", "u": "ㄧ", "v": "ㄒ",
+    "l": "ㄤ", "m": "ㄩ", "n": "ㄙ", "o": "ㄢ", "p": "ㄦ", "q": "ㄅ", "r": "ㄐ", "s": "ㄋ", "t": "ㄓ", "u": "ㄧ", "v": "ㄒ",
-    "w": "ㄊ", "x": "ㄌ", "y": "ㄗ", "z": "ㄈ", " ": " ",
+    "w": "ㄉ", "x": "ㄌ", "y": "ㄗ", "z": "ㄈ", " ": " ",
   ]
 
   /// 許氏排列專用處理陣列，但未包含全部的映射內容。
@@ -552,7 +552,7 @@ public enum Tekkon {
   /// 在這裡將二十六個字母寫全，也只是為了方便做 validity check。
   /// 這裡提前對複音按鍵做處理，然後再用程式判斷介母類型、據此判斷是否需要做複音切換。
   static let mapHsuStaticKeys: [String: String] = [
-    "a": "ㄘ", "b": "ㄅ", "c": "ㄒ", "d": "ㄉ", "e": "ㄧ", "f": "ㄈ", "g": "ㄍ", "h": "ㄏ", "i": "ㄞ", "j": "ㄐ", "k": "ㄎ",
+    "a": "ㄘ", "b": "ㄅ", "c": "ㄕ", "d": "ㄉ", "e": "ㄧ", "f": "ㄈ", "g": "ㄍ", "h": "ㄏ", "i": "ㄞ", "j": "ㄐ", "k": "ㄎ",
     "l": "ㄌ", "m": "ㄇ", "n": "ㄋ", "o": "ㄡ", "p": "ㄆ", "r": "ㄖ", "s": "ㄙ", "t": "ㄊ", "u": "ㄩ", "v": "ㄔ", "w": "ㄠ",
     "x": "ㄨ", "y": "ㄚ", "z": "ㄗ", " ": " ",
   ]
@@ -574,8 +574,18 @@ public enum Tekkon {
   static let mapStarlightStaticKeys: [String: String] = [
     "a": "ㄚ", "b": "ㄅ", "c": "ㄘ", "d": "ㄉ", "e": "ㄜ", "f": "ㄈ", "g": "ㄍ", "h": "ㄏ", "i": "ㄧ", "j": "ㄓ", "k": "ㄎ",
     "l": "ㄌ", "m": "ㄇ", "n": "ㄋ", "o": "ㄛ", "p": "ㄆ", "q": "ㄔ", "r": "ㄖ", "s": "ㄙ", "t": "ㄊ", "u": "ㄨ", "v": "ㄩ",
-    "w": "ㄡ", "x": "ㄕ", "y": "ㄞ", "z": "ㄗ", " ": " ", "1": " ", "2": "ˊ", "3": "ˇ", "4": "ˋ", "5": "˙", "6": " ",
+    "w": "ㄡ", "x": "ㄕ", "y": "ㄞ", "z": "ㄗ", "1": " ", "2": "ˊ", "3": "ˇ", "4": "ˋ", "5": "˙", "6": " ",
-    "7": "ˊ", "8": "ˇ", "9": "ˋ", "0": "˙",
+    "7": "ˊ", "8": "ˇ", "9": "ˋ", "0": "˙", " ": " ",
+  ]
+
+  /// 劉氏擬音注音排列預處理專用陣列，但未包含全部的映射內容。
+  ///
+  /// 在這裡將二十六個字母寫全，也只是為了方便做 validity check。
+  /// 這裡提前對複音按鍵做處理，然後再用程式判斷介母類型、據此判斷是否需要做複音切換。
+  static let mapAlvinLiuStaticKeys: [String: String] = [
+    "q": "ㄑ", "w": "ㄠ", "e": "ㄜ", "r": "ㄖ", "t": "ㄊ", "y": "ㄩ", "u": "ㄨ", "i": "ㄧ", "o": "ㄛ", "p": "ㄆ", "a": "ㄚ",
+    "s": "ㄙ", "d": "ㄉ", "f": "ㄈ", "g": "ㄍ", "h": "ㄏ", "j": "ㄐ", "k": "ㄎ", "l": "ㄦ", "z": "ㄗ", "x": "ㄒ", "c": "ㄘ",
+    "v": "ㄡ", "b": "ㄅ", "n": "ㄋ", "m": "ㄇ", " ": " ",
   ]
 
   /// 倚天傳統排列專用處理陣列。

Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_Phonabets.swift

@@ -32,6 +32,7 @@ public extension Tekkon {
     case ofSeigyou = 7
     case ofFakeSeigyou = 8
     case ofStarlight = 9
+    case ofAlvinLiu = 10
     case ofHanyuPinyin = 100
     case ofSecondaryPinyin = 101
     case ofYalePinyin = 102
@@ -61,6 +62,8 @@ public extension Tekkon {
         return "Seigyou"
       case .ofStarlight:
         return "Starlight"
+      case .ofAlvinLiu:
+        return "AlvinLiu"
       case .ofHanyuPinyin:
         return "HanyuPinyin"
       case .ofSecondaryPinyin:
@@ -88,9 +91,8 @@ public extension Tekkon {
     public var type: PhoneType = .null
     private var valueStorage = ""
     public var value: String { valueStorage }
-    public var isEmpty: Bool {
+    public var isEmpty: Bool { value.isEmpty }
-      value.isEmpty
+    public var isValid: Bool { type != .null }
-    }
 
     /// 初期化，會根據傳入的 input 字串參數來自動判定自身的 PhoneType 類型屬性值。
     public init(_ input: String = "") {

Packages/vChewing_Tekkon/Sources/Tekkon/Tekkon_SyllableComposer.swift

@@ -49,6 +49,14 @@ public extension Tekkon {
     /// 當前注拼槽是否處於拼音模式。
     public var isPinyinMode: Bool { parser.rawValue >= 100 }
 
+    /// 統計有效的聲介韻（調）個數。
+    /// - Parameter withIntonation: 是否統計聲調。
+    /// - Returns: 統計出的有效 Phonabet 個數。
+    public func count(withIntonation: Bool = false) -> Int {
+      [consonant.isValid, semivowel.isValid, vowel.isValid]
+        .reduce((withIntonation && intonation.isValid) ? 1 : 0) { $0 + ($1 ? 1 : 0) }
+    }
+
     /// 與 value 類似，這個函式就是用來決定輸入法組字區內顯示的注音/拼音內容，
     /// 但可以指定是否輸出教科書格式（拼音的調號在字母上方、注音的輕聲寫在左側）。
     /// - Parameters:
@@ -148,6 +156,8 @@ public extension Tekkon {
           return Tekkon.mapFakeSeigyou[input] != nil
         case .ofStarlight:
           return Tekkon.mapStarlightStaticKeys[input] != nil
+        case .ofAlvinLiu:
+          return Tekkon.mapAlvinLiuStaticKeys[input] != nil
         case .ofWadeGilesPinyin:
           return Tekkon.mapWadeGilesPinyinKeys.contains(input)
         case .ofHanyuPinyin, .ofSecondaryPinyin, .ofYalePinyin, .ofHualuoPinyin, .ofUniversalPinyin:
@@ -167,24 +177,16 @@ public extension Tekkon {
     ///   - strOf: 要取代的內容。
     ///   - strWith: 要取代成的內容。
     mutating func fixValue(_ strOf: String, _ strWith: String = "") {
+      guard !strOf.isEmpty, !strWith.isEmpty else { return }
       let theOld = Phonabet(strOf)
-      if !strOf.isEmpty {
+      switch theOld {
-        switch theOld.type {
+      case consonant: consonant.clear()
-        case .consonant where consonant == theOld: consonant.clear()
+      case semivowel: semivowel.clear()
-        case .semivowel where semivowel == theOld: semivowel.clear()
+      case vowel: vowel.clear()
-        case .vowel where vowel == theOld: vowel.clear()
+      case intonation: intonation.clear()
-        case .intonation where intonation == theOld: intonation.clear()
+      default: return
-        default: return
-        }
-      }
-      let theNew = Phonabet(strWith)
-      switch theNew.type {
-      case .consonant: consonant = theNew
-      case .semivowel: semivowel = theNew
-      case .vowel: vowel = theNew
-      case .intonation: intonation = theNew
-      case .null: return
       }
+      receiveKey(fromPhonabet: strWith)
     }
 
     /// 接受傳入的按鍵訊號時的處理，處理對象為 String。
@@ -237,32 +239,32 @@ public extension Tekkon {
         case "ㄧ", "ㄩ":
           if vowel.value == "ㄜ" { vowel = "ㄝ" }
         case "ㄜ":
-          if "ㄨ".contains(semivowel.value) { semivowel = "ㄩ" }
+          if "ㄨ".doesHave(semivowel.value) { semivowel = "ㄩ" }
-          if "ㄧㄩ".contains(semivowel.value) { thePhone = "ㄝ" }
+          if "ㄧㄩ".doesHave(semivowel.value) { thePhone = "ㄝ" }
         case "ㄝ":
-          if "ㄨ".contains(semivowel.value) { semivowel = "ㄩ" }
+          if "ㄨ".doesHave(semivowel.value) { semivowel = "ㄩ" }
         case "ㄛ", "ㄥ":
           if phonabet == "ㄛ", semivowel.value == "ㄩ" { semivowel = "ㄨ" }
-          if "ㄅㄆㄇㄈ".contains(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() }
+          if "ㄅㄆㄇㄈ".doesHave(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() }
         case "ㄟ":
-          if "ㄋㄌ".contains(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() }
+          if "ㄋㄌ".doesHave(consonant.value), semivowel.value == "ㄨ" { semivowel.clear() }
         case "ㄨ":
-          if "ㄅㄆㄇㄈ".contains(consonant.value), "ㄛㄥ".contains(vowel.value) { vowel.clear() }
+          if "ㄅㄆㄇㄈ".doesHave(consonant.value), "ㄛㄥ".doesHave(vowel.value) { vowel.clear() }
-          if "ㄋㄌ".contains(consonant.value), "ㄟ".contains(vowel.value) { vowel.clear() }
+          if "ㄋㄌ".doesHave(consonant.value), "ㄟ".doesHave(vowel.value) { vowel.clear() }
-          if "ㄜ".contains(vowel.value) { vowel = "ㄝ" }
+          if "ㄜ".doesHave(vowel.value) { vowel = "ㄝ" }
-          if "ㄝ".contains(vowel.value) { thePhone = "ㄩ" }
+          if "ㄝ".doesHave(vowel.value) { thePhone = "ㄩ" }
         case "ㄅ", "ㄆ", "ㄇ", "ㄈ":
           if ["ㄨㄛ", "ㄨㄥ"].contains(semivowel.value + vowel.value) { semivowel.clear() }
         default: break
         }
-        if [.vowel, .intonation].contains(thePhone.type), "ㄓㄔㄕㄗㄘㄙ".contains(consonant.value) {
+        if [.vowel, .intonation].contains(thePhone.type), "ㄓㄔㄕㄗㄘㄙ".doesHave(consonant.value) {
           switch semivowel.value {
           case "ㄧ": semivowel.clear()
           case "ㄩ":
             switch consonant {
-            case _ where "ㄓㄗ".contains(consonant.value): consonant = "ㄐ"
+            case _ where "ㄓㄗ".doesHave(consonant.value): consonant = "ㄐ"
-            case _ where "ㄔㄘ".contains(consonant.value): consonant = "ㄑ"
+            case _ where "ㄔㄘ".doesHave(consonant.value): consonant = "ㄑ"
-            case _ where "ㄕㄙ".contains(consonant.value): consonant = "ㄒ"
+            case _ where "ㄕㄙ".doesHave(consonant.value): consonant = "ㄒ"
             default: break
             }
           default: break
@@ -410,12 +412,14 @@ public extension Tekkon {
         return Tekkon.mapFakeSeigyou[key] ?? ""
       case .ofStarlight:
         return handleStarlight(key: key)
+      case .ofAlvinLiu:
+        return handleAlvinLiu(key: key)
       default:
         return ""
       }
     }
 
-    /// 所有動態注音鍵盤佈局都會用到的共用糾錯處理步驟。
+    /// 所有動態注音排列都會用到的共用糾錯處理步驟。
     /// - Parameter incomingPhonabet: 傳入的注音 Phonabet。
     public mutating func commonFixWhenHandlingDynamicArrangeInputs(target incomingPhonabet: Phonabet) {
       // 處理特殊情形。
@@ -424,7 +428,7 @@ public extension Tekkon {
         switch consonant {
         case "ㄍ":
           switch incomingPhonabet {
-          case "ㄧ": consonant = "ㄑ" // ㄑㄧ
+          // 這裡不處理「ㄍㄧ」到「ㄑㄧ」的轉換，因為只有倚天26需要處理這個。
           case "ㄨ": consonant = "ㄍ" // ㄍㄨ
           case "ㄩ": consonant = "ㄑ" // ㄑㄩ
           default: break
@@ -452,6 +456,11 @@ public extension Tekkon {
           }
         default: break
         }
+        if incomingPhonabet == "ㄨ" {
+          fixValue("ㄐ", "ㄓ")
+          fixValue("ㄑ", "ㄔ")
+          fixValue("ㄒ", "ㄕ")
+        }
       case .vowel:
         if semivowel.isEmpty {
           fixValue("ㄐ", "ㄓ")
@@ -462,46 +471,41 @@ public extension Tekkon {
       }
     }
 
-    /// 倚天忘形注音排列比較麻煩，需要單獨處理。
+    /// 倚天忘形注音排列是複合注音排列，需要單獨處理。
     ///
     /// 回傳結果是空字串的話，不要緊，因為該函式內部已經處理過分配過程了。
     /// - Parameters:
     ///   - key: 傳入的 String 訊號。
     public mutating func handleETen26(key: String = "") -> String {
       var strReturn = Tekkon.mapETen26StaticKeys[key] ?? ""
-      let incomingPhonabet = Phonabet(strReturn)
+
+      let keysToHandleHere = "dfhjklmnpqtw"
 
       switch key {
-      case "d": if !isPronouncable { consonant = "ㄉ" } else { intonation = "˙" }
+      case "d" where isPronouncable: strReturn = "˙"
-      case "f": if !isPronouncable { consonant = "ㄈ" } else { intonation = "ˊ" }
+      case "f" where isPronouncable: strReturn = "ˊ"
-      case "j": if !isPronouncable { consonant = "ㄖ" } else { intonation = "ˇ" }
+      case "j" where isPronouncable: strReturn = "ˇ"
-      case "k": if !isPronouncable { consonant = "ㄎ" } else { intonation = "ˋ" }
+      case "k" where isPronouncable: strReturn = "ˋ"
-      case "h": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄏ" } else { vowel = "ㄦ" }
+      case "e" where consonant == "ㄍ": consonant = "ㄑ"
-      case "l": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄌ" } else { vowel = "ㄥ" }
+      case "p" where !consonant.isEmpty || semivowel == "ㄧ": strReturn = "ㄡ"
-      case "m": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄇ" } else { vowel = "ㄢ" }
+      case "h" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄦ"
-      case "n": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄋ" } else { vowel = "ㄣ" }
+      case "l" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄥ"
-      case "q": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄗ" } else { vowel = "ㄟ" }
+      case "m" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄢ"
-      case "t": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄊ" } else { vowel = "ㄤ" }
+      case "n" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄣ"
-      case "w": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄘ" } else { vowel = "ㄝ" }
+      case "q" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄟ"
-      case "p":
+      case "t" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄤ"
-        if consonant.isEmpty, semivowel.isEmpty {
+      case "w" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄝ"
-          consonant = "ㄆ"
-        } else if consonant.isEmpty, semivowel == "ㄧ" {
-          vowel = "ㄡ"
-        } else if consonant.isEmpty {
-          consonant = "ㄆ"
-        } else {
-          vowel = "ㄡ"
-        }
       default: break
       }
 
-      // 處理特殊情形。
+      if keysToHandleHere.doesHave(key) {
-      commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet)
+        receiveKey(fromPhonabet: strReturn)
+      }
 
-      if "dfjk ".contains(key),
+      // 處理公共特殊情形。
-         !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty
+      commonFixWhenHandlingDynamicArrangeInputs(target: Phonabet(strReturn))
-      {
+
+      if "dfjk ".doesHave(key), count() == 1 {
         fixValue("ㄆ", "ㄡ")
         fixValue("ㄇ", "ㄢ")
         fixValue("ㄊ", "ㄤ")
@@ -514,131 +518,124 @@ public extension Tekkon {
       if value == "ㄍ˙" { consonant = "ㄑ" }
 
       // 這些按鍵在上文處理過了，就不要再回傳了。
-      if "dfhjklmnpqtw".contains(key) { strReturn = "" }
+      if keysToHandleHere.doesHave(key) { strReturn = "" }
 
       // 回傳結果是空字串的話，不要緊，因為上文已經代處理過分配過程了。
       return strReturn
     }
 
-    /// 許氏鍵盤與倚天忘形一樣同樣也比較麻煩，需要單獨處理。
+    /// 許氏注音排列是複合注音排列，需要單獨處理。
     ///
     /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。
     /// - Parameters:
     ///   - key: 傳入的 String 訊號。
     public mutating func handleHsu(key: String = "") -> String {
       var strReturn = Tekkon.mapHsuStaticKeys[key] ?? ""
-      let incomingPhonabet = Phonabet(strReturn)
 
-      if key == " ", value == "ㄋ" {
+      let keysToHandleHere = "acdefghjklmns"
-        consonant.clear()
-        vowel = "ㄣ"
-      }
 
       switch key {
-      case "d": if isPronouncable { intonation = "ˊ" } else { consonant = "ㄉ" }
+      case "d" where isPronouncable: strReturn = "ˊ"
-      case "f": if isPronouncable { intonation = "ˇ" } else { consonant = "ㄈ" }
+      case "f" where isPronouncable: strReturn = "ˇ"
-      case "s": if isPronouncable { intonation = "˙" } else { consonant = "ㄙ" }
+      case "s" where isPronouncable: strReturn = "˙"
-      case "j": if isPronouncable { intonation = "ˋ" } else { consonant = "ㄓ" }
+      case "j" where isPronouncable: strReturn = "ˋ"
-      case "a": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄘ" } else { vowel = "ㄟ" }
+      case "a" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄟ"
-      case "v": if semivowel.isEmpty { consonant = "ㄔ" } else { consonant = "ㄑ" }
+      case "v" where !semivowel.isEmpty: strReturn = "ㄑ"
-      case "c": if semivowel.isEmpty { consonant = "ㄕ" } else { consonant = "ㄒ" }
+      case "c" where !semivowel.isEmpty: strReturn = "ㄒ"
-      case "e": if semivowel.isEmpty { semivowel = "ㄧ" } else { vowel = "ㄝ" }
+      case "e" where !semivowel.isEmpty: strReturn = "ㄝ"
-      case "g": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄍ" } else { vowel = "ㄜ" }
+      case "g" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄜ"
-      case "h": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄏ" } else { vowel = "ㄛ" }
+      case "h" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄛ"
-      case "k": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄎ" } else { vowel = "ㄤ" }
+      case "k" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄤ"
-      case "m": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄇ" } else { vowel = "ㄢ" }
+      case "m" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄢ"
-      case "n": if consonant.isEmpty, semivowel.isEmpty { consonant = "ㄋ" } else { vowel = "ㄣ" }
+      case "n" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄣ"
       case "l":
         if value.isEmpty, !consonant.isEmpty, !semivowel.isEmpty {
-          vowel = "ㄦ"
+          strReturn = "ㄦ"
         } else if consonant.isEmpty, semivowel.isEmpty {
-          consonant = "ㄌ"
+          strReturn = "ㄌ"
         } else {
-          vowel = "ㄥ"
+          strReturn = "ㄥ"
         }
       default: break
       }
 
-      // 處理特殊情形。
+      if keysToHandleHere.doesHave(key) {
-      commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet)
+        receiveKey(fromPhonabet: strReturn)
+      }
 
-      if "dfjs ".contains(key) {
+      // 處理公共特殊情形。
-        if !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty {
+      commonFixWhenHandlingDynamicArrangeInputs(target: Phonabet(strReturn))
-          fixValue("ㄍ", "ㄜ")
+
-          fixValue("ㄋ", "ㄣ")
+      if "dfjs ".doesHave(key), count() == 1 {
-          fixValue("ㄌ", "ㄦ")
+        fixValue("ㄒ", "ㄕ")
-          fixValue("ㄎ", "ㄤ")
+        fixValue("ㄍ", "ㄜ")
-          fixValue("ㄇ", "ㄢ")
+        fixValue("ㄋ", "ㄣ")
-        }
+        fixValue("ㄌ", "ㄦ")
-        if "ㄢㄣㄤㄥ".contains(vowel.value), semivowel.isEmpty {
+        fixValue("ㄎ", "ㄤ")
-          fixValue("ㄐ", "ㄓ")
+        fixValue("ㄇ", "ㄢ")
-          fixValue("ㄑ", "ㄔ")
+        fixValue("ㄐ", "ㄓ")
-          fixValue("ㄒ", "ㄕ")
+        fixValue("ㄑ", "ㄔ")
-        }
+        fixValue("ㄒ", "ㄕ")
-        if "ㄐㄑㄒ".contains(consonant.value), semivowel.isEmpty {
+        fixValue("ㄏ", "ㄛ")
-          fixValue("ㄐ", "ㄓ")
-          fixValue("ㄑ", "ㄔ")
-          fixValue("ㄒ", "ㄕ")
-        }
-        if consonant == "ㄏ", semivowel.isEmpty, vowel.isEmpty {
-          consonant.clear()
-          vowel = "ㄛ"
-        }
       }
 
       // 後置修正
       if value == "ㄔ˙" { consonant = "ㄑ" }
 
       // 這些按鍵在上文處理過了，就不要再回傳了。
-      if "acdefghjklmns".contains(key) { strReturn = "" }
+      if keysToHandleHere.doesHave(key) { strReturn = "" }
 
       // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。
       return strReturn
     }
 
-    /// 星光排列一樣同樣也比較麻煩，需要單獨處理。
+    /// 星光注音排列是複合注音排列，需要單獨處理。
     ///
     /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。
     /// - Parameters:
     ///   - key: 傳入的 String 訊號。
     public mutating func handleStarlight(key: String) -> String {
       var strReturn = Tekkon.mapStarlightStaticKeys[key] ?? ""
-      let incomingPhonabet = Phonabet(strReturn)
+
+      let keysToHandleHere = "efgklmnt"
+
       switch key {
-      case "e": return "ㄧㄩ".contains(semivowel.value) ? "ㄝ" : "ㄜ"
+      case "e" where "ㄧㄩ".doesHave(semivowel.value): strReturn = "ㄝ"
-      case "f": return vowel == "ㄠ" || !isPronouncable ? "ㄈ" : "ㄠ"
+      case "f" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄠ"
-      case "g": return vowel == "ㄥ" || !isPronouncable ? "ㄍ" : "ㄥ"
+      case "g" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄥ"
-      case "k": return vowel == "ㄤ" || !isPronouncable ? "ㄎ" : "ㄤ"
+      case "k" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄤ"
-      case "l": return vowel == "ㄦ" || !isPronouncable ? "ㄌ" : "ㄦ"
+      case "l" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄦ"
-      case "m": return vowel == "ㄢ" || !isPronouncable ? "ㄇ" : "ㄢ"
+      case "m" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄢ"
-      case "n": return vowel == "ㄣ" || !isPronouncable ? "ㄋ" : "ㄣ"
+      case "n" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄣ"
-      case "t": return vowel == "ㄟ" || !isPronouncable ? "ㄊ" : "ㄟ"
+      case "t" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄟ"
       default: break
       }
 
-      // 處理特殊情形。
+      if keysToHandleHere.doesHave(key) {
-      commonFixWhenHandlingDynamicArrangeInputs(target: incomingPhonabet)
+        receiveKey(fromPhonabet: strReturn)
+      }
 
-      if "67890 ".contains(key) {
+      // 處理公共特殊情形。
-        if !consonant.isEmpty, semivowel.isEmpty, vowel.isEmpty {
+      commonFixWhenHandlingDynamicArrangeInputs(target: Phonabet(strReturn))
-          fixValue("ㄈ", "ㄠ")
+
-          fixValue("ㄍ", "ㄥ")
+      if "67890 ".doesHave(key), count() == 1 {
-          fixValue("ㄎ", "ㄤ")
+        fixValue("ㄈ", "ㄠ")
-          fixValue("ㄌ", "ㄦ")
+        fixValue("ㄍ", "ㄥ")
-          fixValue("ㄇ", "ㄢ")
+        fixValue("ㄎ", "ㄤ")
-          fixValue("ㄋ", "ㄣ")
+        fixValue("ㄌ", "ㄦ")
-          fixValue("ㄊ", "ㄟ")
+        fixValue("ㄇ", "ㄢ")
-        }
+        fixValue("ㄋ", "ㄣ")
+        fixValue("ㄊ", "ㄟ")
       }
 
       // 這些按鍵在上文處理過了，就不要再回傳了。
-      if "efgklmn".contains(key) { strReturn = "" }
+      if keysToHandleHere.doesHave(key) { strReturn = "" }
 
       // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。
       return strReturn
     }
 
-    /// 大千忘形一樣同樣也比較麻煩，需要單獨處理。
+    /// 酷音大千二十六鍵注音排列是複合注音排列，需要單獨處理。
     ///
     /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。
     /// - Parameters:
@@ -647,61 +644,112 @@ public extension Tekkon {
       var strReturn = Tekkon.mapDachenCP26StaticKeys[key] ?? ""
 
       switch key {
-      case "e": if isPronouncable { intonation = "ˊ" } else { consonant = "ㄍ" }
+      case "e" where isPronouncable: strReturn = "ˊ"
-      case "r": if isPronouncable { intonation = "ˇ" } else { consonant = "ㄐ" }
+      case "r" where isPronouncable: strReturn = "ˇ"
-      case "d": if isPronouncable { intonation = "ˋ" } else { consonant = "ㄎ" }
+      case "d" where isPronouncable: strReturn = "ˋ"
-      case "y": if isPronouncable { intonation = "˙" } else { consonant = "ㄗ" }
+      case "y" where isPronouncable: strReturn = "˙"
-      case "b": if !consonant.isEmpty || !semivowel.isEmpty { vowel = "ㄝ" } else { consonant = "ㄖ" }
+      case "b" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄝ"
-      case "i": if vowel.isEmpty || vowel == "ㄞ" { vowel = "ㄛ" } else { vowel = "ㄞ" }
+      case "i" where vowel.isEmpty || vowel == "ㄞ": strReturn = "ㄛ"
-      case "l": if vowel.isEmpty || vowel == "ㄤ" { vowel = "ㄠ" } else { vowel = "ㄤ" }
+      case "l" where vowel.isEmpty || vowel == "ㄤ": strReturn = "ㄠ"
-      case "n":
+      case "n" where !consonant.isEmpty || !semivowel.isEmpty:
-        if !consonant.isEmpty || !semivowel.isEmpty {
+        if value == "ㄙ" { consonant.clear() }
-          if consonant == "ㄙ", semivowel.isEmpty, vowel.isEmpty { consonant.clear() }
+        strReturn = "ㄥ"
-          vowel = "ㄥ"
+      case "o" where vowel.isEmpty || vowel == "ㄢ": strReturn = "ㄟ"
-        } else {
+      case "p" where vowel.isEmpty || vowel == "ㄦ": strReturn = "ㄣ"
-          consonant = "ㄙ"
+      case "q" where consonant.isEmpty || consonant == "ㄅ": strReturn = "ㄆ"
-        }
+      case "t" where consonant.isEmpty || consonant == "ㄓ": strReturn = "ㄔ"
-      case "o": if vowel.isEmpty || vowel == "ㄢ" { vowel = "ㄟ" } else { vowel = "ㄢ" }
+      case "w" where consonant.isEmpty || consonant == "ㄉ": strReturn = "ㄊ"
-      case "p": if vowel.isEmpty || vowel == "ㄦ" { vowel = "ㄣ" } else { vowel = "ㄦ" }
-      case "q": if consonant.isEmpty || consonant == "ㄅ" { consonant = "ㄆ" } else { consonant = "ㄅ" }
-      case "t": if consonant.isEmpty || consonant == "ㄓ" { consonant = "ㄔ" } else { consonant = "ㄓ" }
-      case "w": if consonant.isEmpty || consonant == "ㄉ" { consonant = "ㄊ" } else { consonant = "ㄉ" }
       case "m":
         if semivowel == "ㄩ", vowel != "ㄡ" {
           semivowel.clear()
-          vowel = "ㄡ"
+          strReturn = "ㄡ"
         } else if semivowel != "ㄩ", vowel == "ㄡ" {
-          semivowel = "ㄩ"
           vowel.clear()
+          strReturn = "ㄩ"
         } else if !semivowel.isEmpty {
-          vowel = "ㄡ"
+          strReturn = "ㄡ"
         } else {
-          receiveKey(fromPhonabet: "ㄐㄑㄒ".contains(consonant.value) ? "ㄩ" : "ㄡ")
+          strReturn = "ㄐㄑㄒ".doesHave(consonant.value) ? "ㄩ" : "ㄡ"
         }
       case "u":
         if semivowel == "ㄧ", vowel != "ㄚ" {
           semivowel.clear()
-          vowel = "ㄚ"
+          strReturn = "ㄚ"
         } else if semivowel != "ㄧ", vowel == "ㄚ" {
-          semivowel = "ㄧ"
+          strReturn = "ㄧ"
         } else if semivowel == "ㄧ", vowel == "ㄚ" {
           semivowel.clear()
           vowel.clear()
         } else if !semivowel.isEmpty {
-          vowel = "ㄚ"
+          strReturn = "ㄚ"
         } else {
-          semivowel = "ㄧ"
+          strReturn = "ㄧ"
         }
       default: break
       }
 
-      // 這些按鍵在上文處理過了，就不要再回傳了。
-      if "qwtilopnbmuerdy".contains(key) { strReturn = "" }
-
       // 回傳結果是空的話，不要緊，因為上文已經代處理過分配過程了。
       return strReturn
     }
 
+    /// 劉氏擬音注音排列是複合注音排列，需要單獨處理。
+    ///
+    /// 回傳結果是空的話，不要緊，因為該函式內部已經處理過分配過程了。
+    /// - Remark: 該處理兼顧了「原旨排列方案」與「微軟新注音相容排列方案」。
+    /// - Parameters:
+    ///   - key: 傳入的 String 訊號。
+    public mutating func handleAlvinLiu(key: String) -> String {
+      var strReturn = Tekkon.mapAlvinLiuStaticKeys[key] ?? ""
+
+      // 前置處理專有特殊情形。
+      if strReturn != "ㄦ" && !vowel.isEmpty { fixValue("ㄦ", "ㄌ") }
+
+      let keysToHandleHere = "dfjlegnhkbmc"
+
+      switch key {
+      case "d" where isPronouncable: strReturn = "˙"
+      case "f" where isPronouncable: strReturn = "ˊ"
+      case "j" where isPronouncable: strReturn = "ˇ"
+      case "l" where isPronouncable: strReturn = "ˋ"
+      case "e" where "ㄧㄩ".doesHave(semivowel.value): strReturn = "ㄝ"
+      case "g" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄤ"
+      case "n" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄣ"
+      case "h" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄞ"
+      case "k" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄟ"
+      case "b" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄢ"
+      case "m" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄥ"
+      case "c" where !consonant.isEmpty || !semivowel.isEmpty: strReturn = "ㄝ"
+      default: break
+      }
+
+      if keysToHandleHere.doesHave(key) {
+        receiveKey(fromPhonabet: strReturn)
+      }
+
+      // 處理公共特殊情形。
+      commonFixWhenHandlingDynamicArrangeInputs(target: Phonabet(strReturn))
+
+      if "dfjl ".doesHave(key), count() == 1 {
+        fixValue("ㄑ", "ㄔ")
+        fixValue("ㄊ", "ㄦ")
+        fixValue("ㄍ", "ㄤ")
+        fixValue("ㄏ", "ㄞ")
+        fixValue("ㄐ", "ㄓ")
+        fixValue("ㄎ", "ㄟ")
+        fixValue("ㄌ", "ㄦ")
+        fixValue("ㄒ", "ㄕ")
+        fixValue("ㄅ", "ㄢ")
+        fixValue("ㄋ", "ㄣ")
+        fixValue("ㄇ", "ㄥ")
+      }
+
+      // 這些按鍵在上文處理過了，就不要再回傳了。
+      if keysToHandleHere.doesHave(key) { strReturn = "" }
+
+      // 回傳結果是空字串的話，不要緊，因為上文已經代處理過分配過程了。
+      return strReturn
+    }
+
     // MARK: - Misc Definitions
 
     /// 這些內容用來滿足 "Equatable, Hashable, ExpressibleByStringLiteral" 需求。
@@ -730,3 +778,9 @@ public extension Tekkon {
     }
   }
 }
+
+private extension String {
+  func doesHave(_ target: String) -> Bool {
+    target.isEmpty ? isEmpty : contains(target)
+  }
+}

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_A.swift

@@ -0,0 +1,509 @@
+// (c) 2022 and onwards The vChewing Project (MIT-NTL License).
+// ====================
+// This code is released under the MIT license (SPDX-License-Identifier: MIT)
+// ... with NTL restriction stating that:
+// No trademark license is granted to use the trade names, trademarks, service
+// marks, or product names of Contributor, except as required to fulfill notice
+// requirements defined in MIT License.
+
+import XCTest
+
+@testable import Tekkon
+
+extension TekkonTestsKeyboardArrangments {
+  func testAlvinLiuKeysTaigi() throws {
+    var c = Tekkon.Composer(arrange: .ofAlvinLiu)
+    XCTAssertEqual(c.cS2RC("kig"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("giwf"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("gin"), "ㄍㄧㄣ")
+  }
+
+  func testAlvinLiuKeysA() throws {
+    var c = Tekkon.Composer(arrange: .ofAlvinLiu)
+    XCTAssertEqual(c.cS2RC("kig"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("giwf"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("gin"), "ㄍㄧㄣ")
+    XCTAssertEqual(c.cS2RC("bigf"), "ㄅㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("bigl"), "ㄅㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("dug"), "ㄉㄨㄤ")
+    XCTAssertEqual(c.cS2RC("ba"), "ㄅㄚ")
+    XCTAssertEqual(c.cS2RC("baf"), "ㄅㄚˊ")
+    XCTAssertEqual(c.cS2RC("baj"), "ㄅㄚˇ")
+    XCTAssertEqual(c.cS2RC("bal"), "ㄅㄚˋ")
+    XCTAssertEqual(c.cS2RC("bad"), "ㄅㄚ˙")
+    XCTAssertEqual(c.cS2RC("bo"), "ㄅㄛ")
+    XCTAssertEqual(c.cS2RC("bof"), "ㄅㄛˊ")
+    XCTAssertEqual(c.cS2RC("boj"), "ㄅㄛˇ")
+    XCTAssertEqual(c.cS2RC("bol"), "ㄅㄛˋ")
+    XCTAssertEqual(c.cS2RC("bod"), "ㄅㄛ˙")
+    XCTAssertEqual(c.cS2RC("bh"), "ㄅㄞ")
+    XCTAssertEqual(c.cS2RC("bhf"), "ㄅㄞˊ")
+    XCTAssertEqual(c.cS2RC("bhj"), "ㄅㄞˇ")
+    XCTAssertEqual(c.cS2RC("bhl"), "ㄅㄞˋ")
+    XCTAssertEqual(c.cS2RC("bhd"), "ㄅㄞ˙")
+    XCTAssertEqual(c.cS2RC("bk"), "ㄅㄟ")
+    XCTAssertEqual(c.cS2RC("bkj"), "ㄅㄟˇ")
+    XCTAssertEqual(c.cS2RC("bkl"), "ㄅㄟˋ")
+    XCTAssertEqual(c.cS2RC("bkd"), "ㄅㄟ˙")
+    XCTAssertEqual(c.cS2RC("bw"), "ㄅㄠ")
+    XCTAssertEqual(c.cS2RC("bwf"), "ㄅㄠˊ")
+    XCTAssertEqual(c.cS2RC("bwj"), "ㄅㄠˇ")
+    XCTAssertEqual(c.cS2RC("bwl"), "ㄅㄠˋ")
+    XCTAssertEqual(c.cS2RC("bb"), "ㄅㄢ")
+    XCTAssertEqual(c.cS2RC("bbj"), "ㄅㄢˇ")
+    XCTAssertEqual(c.cS2RC("bbl"), "ㄅㄢˋ")
+    XCTAssertEqual(c.cS2RC("bn"), "ㄅㄣ")
+    XCTAssertEqual(c.cS2RC("bnj"), "ㄅㄣˇ")
+    XCTAssertEqual(c.cS2RC("bnl"), "ㄅㄣˋ")
+    XCTAssertEqual(c.cS2RC("bg"), "ㄅㄤ")
+    XCTAssertEqual(c.cS2RC("bgj"), "ㄅㄤˇ")
+    XCTAssertEqual(c.cS2RC("bgl"), "ㄅㄤˋ")
+    XCTAssertEqual(c.cS2RC("bm"), "ㄅㄥ")
+    XCTAssertEqual(c.cS2RC("bmf"), "ㄅㄥˊ")
+    XCTAssertEqual(c.cS2RC("bmj"), "ㄅㄥˇ")
+    XCTAssertEqual(c.cS2RC("bml"), "ㄅㄥˋ")
+    XCTAssertEqual(c.cS2RC("bi"), "ㄅㄧ")
+    XCTAssertEqual(c.cS2RC("bif"), "ㄅㄧˊ")
+    XCTAssertEqual(c.cS2RC("bij"), "ㄅㄧˇ")
+    XCTAssertEqual(c.cS2RC("bil"), "ㄅㄧˋ")
+    XCTAssertEqual(c.cS2RC("bie"), "ㄅㄧㄝ")
+    XCTAssertEqual(c.cS2RC("bief"), "ㄅㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("biej"), "ㄅㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("biel"), "ㄅㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("biw"), "ㄅㄧㄠ")
+    XCTAssertEqual(c.cS2RC("biwj"), "ㄅㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("biwl"), "ㄅㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("bib"), "ㄅㄧㄢ")
+    XCTAssertEqual(c.cS2RC("bibf"), "ㄅㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("bibj"), "ㄅㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("bibl"), "ㄅㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("bin"), "ㄅㄧㄣ")
+    XCTAssertEqual(c.cS2RC("binj"), "ㄅㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("binl"), "ㄅㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("bim"), "ㄅㄧㄥ")
+    XCTAssertEqual(c.cS2RC("bimj"), "ㄅㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("biml"), "ㄅㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("bu"), "ㄅㄨ")
+    XCTAssertEqual(c.cS2RC("buf"), "ㄅㄨˊ")
+    XCTAssertEqual(c.cS2RC("buj"), "ㄅㄨˇ")
+    XCTAssertEqual(c.cS2RC("bul"), "ㄅㄨˋ")
+    XCTAssertEqual(c.cS2RC("pa"), "ㄆㄚ")
+    XCTAssertEqual(c.cS2RC("paf"), "ㄆㄚˊ")
+    XCTAssertEqual(c.cS2RC("paj"), "ㄆㄚˇ")
+    XCTAssertEqual(c.cS2RC("pal"), "ㄆㄚˋ")
+    XCTAssertEqual(c.cS2RC("pad"), "ㄆㄚ˙")
+    XCTAssertEqual(c.cS2RC("po"), "ㄆㄛ")
+    XCTAssertEqual(c.cS2RC("pof"), "ㄆㄛˊ")
+    XCTAssertEqual(c.cS2RC("poj"), "ㄆㄛˇ")
+    XCTAssertEqual(c.cS2RC("pol"), "ㄆㄛˋ")
+    XCTAssertEqual(c.cS2RC("ph"), "ㄆㄞ")
+    XCTAssertEqual(c.cS2RC("phf"), "ㄆㄞˊ")
+    XCTAssertEqual(c.cS2RC("phj"), "ㄆㄞˇ")
+    XCTAssertEqual(c.cS2RC("phl"), "ㄆㄞˋ")
+    XCTAssertEqual(c.cS2RC("pk"), "ㄆㄟ")
+    XCTAssertEqual(c.cS2RC("pkf"), "ㄆㄟˊ")
+    XCTAssertEqual(c.cS2RC("pkj"), "ㄆㄟˇ")
+    XCTAssertEqual(c.cS2RC("pkl"), "ㄆㄟˋ")
+    XCTAssertEqual(c.cS2RC("pw"), "ㄆㄠ")
+    XCTAssertEqual(c.cS2RC("pwf"), "ㄆㄠˊ")
+    XCTAssertEqual(c.cS2RC("pwj"), "ㄆㄠˇ")
+    XCTAssertEqual(c.cS2RC("pwl"), "ㄆㄠˋ")
+    XCTAssertEqual(c.cS2RC("pv"), "ㄆㄡ")
+    XCTAssertEqual(c.cS2RC("pvf"), "ㄆㄡˊ")
+    XCTAssertEqual(c.cS2RC("pvj"), "ㄆㄡˇ")
+    XCTAssertEqual(c.cS2RC("pvl"), "ㄆㄡˋ")
+    XCTAssertEqual(c.cS2RC("pb"), "ㄆㄢ")
+    XCTAssertEqual(c.cS2RC("pbf"), "ㄆㄢˊ")
+    XCTAssertEqual(c.cS2RC("pbj"), "ㄆㄢˇ")
+    XCTAssertEqual(c.cS2RC("pbl"), "ㄆㄢˋ")
+    XCTAssertEqual(c.cS2RC("pn"), "ㄆㄣ")
+    XCTAssertEqual(c.cS2RC("pnf"), "ㄆㄣˊ")
+    XCTAssertEqual(c.cS2RC("pnj"), "ㄆㄣˇ")
+    XCTAssertEqual(c.cS2RC("pnl"), "ㄆㄣˋ")
+    XCTAssertEqual(c.cS2RC("pg"), "ㄆㄤ")
+    XCTAssertEqual(c.cS2RC("pgf"), "ㄆㄤˊ")
+    XCTAssertEqual(c.cS2RC("pgj"), "ㄆㄤˇ")
+    XCTAssertEqual(c.cS2RC("pgl"), "ㄆㄤˋ")
+    XCTAssertEqual(c.cS2RC("pm"), "ㄆㄥ")
+    XCTAssertEqual(c.cS2RC("pmf"), "ㄆㄥˊ")
+    XCTAssertEqual(c.cS2RC("pmj"), "ㄆㄥˇ")
+    XCTAssertEqual(c.cS2RC("pml"), "ㄆㄥˋ")
+    XCTAssertEqual(c.cS2RC("pi"), "ㄆㄧ")
+    XCTAssertEqual(c.cS2RC("pif"), "ㄆㄧˊ")
+    XCTAssertEqual(c.cS2RC("pij"), "ㄆㄧˇ")
+    XCTAssertEqual(c.cS2RC("pil"), "ㄆㄧˋ")
+    XCTAssertEqual(c.cS2RC("pia"), "ㄆㄧㄚ")
+    XCTAssertEqual(c.cS2RC("pie"), "ㄆㄧㄝ")
+    XCTAssertEqual(c.cS2RC("piej"), "ㄆㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("piel"), "ㄆㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("piw"), "ㄆㄧㄠ")
+    XCTAssertEqual(c.cS2RC("piwf"), "ㄆㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("piwj"), "ㄆㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("piwl"), "ㄆㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("pib"), "ㄆㄧㄢ")
+    XCTAssertEqual(c.cS2RC("pibf"), "ㄆㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("pibj"), "ㄆㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("pibl"), "ㄆㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("pin"), "ㄆㄧㄣ")
+    XCTAssertEqual(c.cS2RC("pinf"), "ㄆㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("pinj"), "ㄆㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("pinl"), "ㄆㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("pim"), "ㄆㄧㄥ")
+    XCTAssertEqual(c.cS2RC("pimf"), "ㄆㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("pimj"), "ㄆㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("piml"), "ㄆㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("pu"), "ㄆㄨ")
+    XCTAssertEqual(c.cS2RC("puf"), "ㄆㄨˊ")
+    XCTAssertEqual(c.cS2RC("puj"), "ㄆㄨˇ")
+    XCTAssertEqual(c.cS2RC("pul"), "ㄆㄨˋ")
+    XCTAssertEqual(c.cS2RC("ma"), "ㄇㄚ")
+    XCTAssertEqual(c.cS2RC("maf"), "ㄇㄚˊ")
+    XCTAssertEqual(c.cS2RC("maj"), "ㄇㄚˇ")
+    XCTAssertEqual(c.cS2RC("mal"), "ㄇㄚˋ")
+    XCTAssertEqual(c.cS2RC("mad"), "ㄇㄚ˙")
+    XCTAssertEqual(c.cS2RC("mo"), "ㄇㄛ")
+    XCTAssertEqual(c.cS2RC("mof"), "ㄇㄛˊ")
+    XCTAssertEqual(c.cS2RC("moj"), "ㄇㄛˇ")
+    XCTAssertEqual(c.cS2RC("mol"), "ㄇㄛˋ")
+    XCTAssertEqual(c.cS2RC("mod"), "ㄇㄛ˙")
+    XCTAssertEqual(c.cS2RC("me"), "ㄇㄜ")
+    XCTAssertEqual(c.cS2RC("mel"), "ㄇㄜˋ")
+    XCTAssertEqual(c.cS2RC("med"), "ㄇㄜ˙")
+    XCTAssertEqual(c.cS2RC("mh"), "ㄇㄞ")
+    XCTAssertEqual(c.cS2RC("mhf"), "ㄇㄞˊ")
+    XCTAssertEqual(c.cS2RC("mhj"), "ㄇㄞˇ")
+    XCTAssertEqual(c.cS2RC("mhl"), "ㄇㄞˋ")
+    XCTAssertEqual(c.cS2RC("mkf"), "ㄇㄟˊ")
+    XCTAssertEqual(c.cS2RC("mkj"), "ㄇㄟˇ")
+    XCTAssertEqual(c.cS2RC("mkl"), "ㄇㄟˋ")
+    XCTAssertEqual(c.cS2RC("mw"), "ㄇㄠ")
+    XCTAssertEqual(c.cS2RC("mwf"), "ㄇㄠˊ")
+    XCTAssertEqual(c.cS2RC("mwj"), "ㄇㄠˇ")
+    XCTAssertEqual(c.cS2RC("mwl"), "ㄇㄠˋ")
+    XCTAssertEqual(c.cS2RC("mvf"), "ㄇㄡˊ")
+    XCTAssertEqual(c.cS2RC("mvj"), "ㄇㄡˇ")
+    XCTAssertEqual(c.cS2RC("mvl"), "ㄇㄡˋ")
+    XCTAssertEqual(c.cS2RC("mb"), "ㄇㄢ")
+    XCTAssertEqual(c.cS2RC("mbf"), "ㄇㄢˊ")
+    XCTAssertEqual(c.cS2RC("mbj"), "ㄇㄢˇ")
+    XCTAssertEqual(c.cS2RC("mbl"), "ㄇㄢˋ")
+    XCTAssertEqual(c.cS2RC("mn"), "ㄇㄣ")
+    XCTAssertEqual(c.cS2RC("mnf"), "ㄇㄣˊ")
+    XCTAssertEqual(c.cS2RC("mnj"), "ㄇㄣˇ")
+    XCTAssertEqual(c.cS2RC("mnl"), "ㄇㄣˋ")
+    XCTAssertEqual(c.cS2RC("mnd"), "ㄇㄣ˙")
+    XCTAssertEqual(c.cS2RC("mg"), "ㄇㄤ")
+    XCTAssertEqual(c.cS2RC("mgf"), "ㄇㄤˊ")
+    XCTAssertEqual(c.cS2RC("mgj"), "ㄇㄤˇ")
+    XCTAssertEqual(c.cS2RC("mgl"), "ㄇㄤˋ")
+    XCTAssertEqual(c.cS2RC("mm"), "ㄇㄥ")
+    XCTAssertEqual(c.cS2RC("mmf"), "ㄇㄥˊ")
+    XCTAssertEqual(c.cS2RC("mmj"), "ㄇㄥˇ")
+    XCTAssertEqual(c.cS2RC("mml"), "ㄇㄥˋ")
+    XCTAssertEqual(c.cS2RC("mi"), "ㄇㄧ")
+    XCTAssertEqual(c.cS2RC("mif"), "ㄇㄧˊ")
+    XCTAssertEqual(c.cS2RC("mij"), "ㄇㄧˇ")
+    XCTAssertEqual(c.cS2RC("mil"), "ㄇㄧˋ")
+    XCTAssertEqual(c.cS2RC("mie"), "ㄇㄧㄝ")
+    XCTAssertEqual(c.cS2RC("mief"), "ㄇㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("miel"), "ㄇㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("miw"), "ㄇㄧㄠ")
+    XCTAssertEqual(c.cS2RC("miwf"), "ㄇㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("miwj"), "ㄇㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("miwl"), "ㄇㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("mivf"), "ㄇㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("mivj"), "ㄇㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("mivl"), "ㄇㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("mib"), "ㄇㄧㄢ")
+    XCTAssertEqual(c.cS2RC("mibf"), "ㄇㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("mibj"), "ㄇㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("mibl"), "ㄇㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("min"), "ㄇㄧㄣ")
+    XCTAssertEqual(c.cS2RC("minf"), "ㄇㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("minj"), "ㄇㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("mimf"), "ㄇㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("mimj"), "ㄇㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("miml"), "ㄇㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("muf"), "ㄇㄨˊ")
+    XCTAssertEqual(c.cS2RC("muj"), "ㄇㄨˇ")
+    XCTAssertEqual(c.cS2RC("mul"), "ㄇㄨˋ")
+    XCTAssertEqual(c.cS2RC("fa"), "ㄈㄚ")
+    XCTAssertEqual(c.cS2RC("faf"), "ㄈㄚˊ")
+    XCTAssertEqual(c.cS2RC("faj"), "ㄈㄚˇ")
+    XCTAssertEqual(c.cS2RC("fal"), "ㄈㄚˋ")
+    XCTAssertEqual(c.cS2RC("fof"), "ㄈㄛˊ")
+    XCTAssertEqual(c.cS2RC("fk"), "ㄈㄟ")
+    XCTAssertEqual(c.cS2RC("fkf"), "ㄈㄟˊ")
+    XCTAssertEqual(c.cS2RC("fkj"), "ㄈㄟˇ")
+    XCTAssertEqual(c.cS2RC("fkl"), "ㄈㄟˋ")
+    XCTAssertEqual(c.cS2RC("fv"), "ㄈㄡ")
+    XCTAssertEqual(c.cS2RC("fvf"), "ㄈㄡˊ")
+    XCTAssertEqual(c.cS2RC("fvj"), "ㄈㄡˇ")
+    XCTAssertEqual(c.cS2RC("fvl"), "ㄈㄡˋ")
+    XCTAssertEqual(c.cS2RC("fb"), "ㄈㄢ")
+    XCTAssertEqual(c.cS2RC("fbf"), "ㄈㄢˊ")
+    XCTAssertEqual(c.cS2RC("fbj"), "ㄈㄢˇ")
+    XCTAssertEqual(c.cS2RC("fbl"), "ㄈㄢˋ")
+    XCTAssertEqual(c.cS2RC("fn"), "ㄈㄣ")
+    XCTAssertEqual(c.cS2RC("fnf"), "ㄈㄣˊ")
+    XCTAssertEqual(c.cS2RC("fnj"), "ㄈㄣˇ")
+    XCTAssertEqual(c.cS2RC("fnl"), "ㄈㄣˋ")
+    XCTAssertEqual(c.cS2RC("fnd"), "ㄈㄣ˙")
+    XCTAssertEqual(c.cS2RC("fg"), "ㄈㄤ")
+    XCTAssertEqual(c.cS2RC("fgf"), "ㄈㄤˊ")
+    XCTAssertEqual(c.cS2RC("fgj"), "ㄈㄤˇ")
+    XCTAssertEqual(c.cS2RC("fgl"), "ㄈㄤˋ")
+    XCTAssertEqual(c.cS2RC("fm"), "ㄈㄥ")
+    XCTAssertEqual(c.cS2RC("fmf"), "ㄈㄥˊ")
+    XCTAssertEqual(c.cS2RC("fmj"), "ㄈㄥˇ")
+    XCTAssertEqual(c.cS2RC("fml"), "ㄈㄥˋ")
+    XCTAssertEqual(c.cS2RC("fiwl"), "ㄈㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("fu"), "ㄈㄨ")
+    XCTAssertEqual(c.cS2RC("fuf"), "ㄈㄨˊ")
+    XCTAssertEqual(c.cS2RC("fuj"), "ㄈㄨˇ")
+    XCTAssertEqual(c.cS2RC("ful"), "ㄈㄨˋ")
+    XCTAssertEqual(c.cS2RC("da"), "ㄉㄚ")
+    XCTAssertEqual(c.cS2RC("daf"), "ㄉㄚˊ")
+    XCTAssertEqual(c.cS2RC("daj"), "ㄉㄚˇ")
+    XCTAssertEqual(c.cS2RC("dal"), "ㄉㄚˋ")
+    XCTAssertEqual(c.cS2RC("dad"), "ㄉㄚ˙")
+    XCTAssertEqual(c.cS2RC("de"), "ㄉㄜ")
+    XCTAssertEqual(c.cS2RC("def"), "ㄉㄜˊ")
+    XCTAssertEqual(c.cS2RC("ded"), "ㄉㄜ˙")
+    XCTAssertEqual(c.cS2RC("dh"), "ㄉㄞ")
+    XCTAssertEqual(c.cS2RC("dhj"), "ㄉㄞˇ")
+    XCTAssertEqual(c.cS2RC("dhl"), "ㄉㄞˋ")
+    XCTAssertEqual(c.cS2RC("dkj"), "ㄉㄟˇ")
+    XCTAssertEqual(c.cS2RC("dw"), "ㄉㄠ")
+    XCTAssertEqual(c.cS2RC("dwf"), "ㄉㄠˊ")
+    XCTAssertEqual(c.cS2RC("dwj"), "ㄉㄠˇ")
+    XCTAssertEqual(c.cS2RC("dwl"), "ㄉㄠˋ")
+    XCTAssertEqual(c.cS2RC("dv"), "ㄉㄡ")
+    XCTAssertEqual(c.cS2RC("dvf"), "ㄉㄡˊ")
+    XCTAssertEqual(c.cS2RC("dvj"), "ㄉㄡˇ")
+    XCTAssertEqual(c.cS2RC("dvl"), "ㄉㄡˋ")
+    XCTAssertEqual(c.cS2RC("db"), "ㄉㄢ")
+    XCTAssertEqual(c.cS2RC("dbj"), "ㄉㄢˇ")
+    XCTAssertEqual(c.cS2RC("dbl"), "ㄉㄢˋ")
+    XCTAssertEqual(c.cS2RC("dnl"), "ㄉㄣˋ")
+    XCTAssertEqual(c.cS2RC("dg"), "ㄉㄤ")
+    XCTAssertEqual(c.cS2RC("dgj"), "ㄉㄤˇ")
+    XCTAssertEqual(c.cS2RC("dgl"), "ㄉㄤˋ")
+    XCTAssertEqual(c.cS2RC("dm"), "ㄉㄥ")
+    XCTAssertEqual(c.cS2RC("dmj"), "ㄉㄥˇ")
+    XCTAssertEqual(c.cS2RC("dml"), "ㄉㄥˋ")
+    XCTAssertEqual(c.cS2RC("di"), "ㄉㄧ")
+    XCTAssertEqual(c.cS2RC("dif"), "ㄉㄧˊ")
+    XCTAssertEqual(c.cS2RC("dij"), "ㄉㄧˇ")
+    XCTAssertEqual(c.cS2RC("dil"), "ㄉㄧˋ")
+    XCTAssertEqual(c.cS2RC("diaj"), "ㄉㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("die"), "ㄉㄧㄝ")
+    XCTAssertEqual(c.cS2RC("dief"), "ㄉㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("diej"), "ㄉㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("diel"), "ㄉㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("diw"), "ㄉㄧㄠ")
+    XCTAssertEqual(c.cS2RC("diwj"), "ㄉㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("diwl"), "ㄉㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("div"), "ㄉㄧㄡ")
+    XCTAssertEqual(c.cS2RC("dib"), "ㄉㄧㄢ")
+    XCTAssertEqual(c.cS2RC("dibf"), "ㄉㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("dibj"), "ㄉㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("dibl"), "ㄉㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("dim"), "ㄉㄧㄥ")
+    XCTAssertEqual(c.cS2RC("dimf"), "ㄉㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("dimj"), "ㄉㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("diml"), "ㄉㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("du"), "ㄉㄨ")
+    XCTAssertEqual(c.cS2RC("duf"), "ㄉㄨˊ")
+    XCTAssertEqual(c.cS2RC("duj"), "ㄉㄨˇ")
+    XCTAssertEqual(c.cS2RC("dul"), "ㄉㄨˋ")
+    XCTAssertEqual(c.cS2RC("duo"), "ㄉㄨㄛ")
+    XCTAssertEqual(c.cS2RC("duof"), "ㄉㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("duoj"), "ㄉㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("duol"), "ㄉㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("duod"), "ㄉㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("duk"), "ㄉㄨㄟ")
+    XCTAssertEqual(c.cS2RC("dukj"), "ㄉㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("dukl"), "ㄉㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("dub"), "ㄉㄨㄢ")
+    XCTAssertEqual(c.cS2RC("dubj"), "ㄉㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("dubl"), "ㄉㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("dun"), "ㄉㄨㄣ")
+    XCTAssertEqual(c.cS2RC("dunj"), "ㄉㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("dunl"), "ㄉㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("dum"), "ㄉㄨㄥ")
+    XCTAssertEqual(c.cS2RC("dumj"), "ㄉㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("duml"), "ㄉㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("ta"), "ㄊㄚ")
+    XCTAssertEqual(c.cS2RC("taj"), "ㄊㄚˇ")
+    XCTAssertEqual(c.cS2RC("tal"), "ㄊㄚˋ")
+    XCTAssertEqual(c.cS2RC("tel"), "ㄊㄜˋ")
+    XCTAssertEqual(c.cS2RC("th"), "ㄊㄞ")
+    XCTAssertEqual(c.cS2RC("thf"), "ㄊㄞˊ")
+    XCTAssertEqual(c.cS2RC("thj"), "ㄊㄞˇ")
+    XCTAssertEqual(c.cS2RC("thl"), "ㄊㄞˋ")
+    XCTAssertEqual(c.cS2RC("thd"), "ㄊㄞ˙")
+    XCTAssertEqual(c.cS2RC("tw"), "ㄊㄠ")
+    XCTAssertEqual(c.cS2RC("twf"), "ㄊㄠˊ")
+    XCTAssertEqual(c.cS2RC("twj"), "ㄊㄠˇ")
+    XCTAssertEqual(c.cS2RC("twl"), "ㄊㄠˋ")
+    XCTAssertEqual(c.cS2RC("twd"), "ㄊㄠ˙")
+    XCTAssertEqual(c.cS2RC("tv"), "ㄊㄡ")
+    XCTAssertEqual(c.cS2RC("tvf"), "ㄊㄡˊ")
+    XCTAssertEqual(c.cS2RC("tvj"), "ㄊㄡˇ")
+    XCTAssertEqual(c.cS2RC("tvl"), "ㄊㄡˋ")
+    XCTAssertEqual(c.cS2RC("tvd"), "ㄊㄡ˙")
+    XCTAssertEqual(c.cS2RC("tb"), "ㄊㄢ")
+    XCTAssertEqual(c.cS2RC("tbf"), "ㄊㄢˊ")
+    XCTAssertEqual(c.cS2RC("tbj"), "ㄊㄢˇ")
+    XCTAssertEqual(c.cS2RC("tbl"), "ㄊㄢˋ")
+    XCTAssertEqual(c.cS2RC("tg"), "ㄊㄤ")
+    XCTAssertEqual(c.cS2RC("tgf"), "ㄊㄤˊ")
+    XCTAssertEqual(c.cS2RC("tgj"), "ㄊㄤˇ")
+    XCTAssertEqual(c.cS2RC("tgl"), "ㄊㄤˋ")
+    XCTAssertEqual(c.cS2RC("tm"), "ㄊㄥ")
+    XCTAssertEqual(c.cS2RC("tmf"), "ㄊㄥˊ")
+    XCTAssertEqual(c.cS2RC("tml"), "ㄊㄥˋ")
+    XCTAssertEqual(c.cS2RC("ti"), "ㄊㄧ")
+    XCTAssertEqual(c.cS2RC("tif"), "ㄊㄧˊ")
+    XCTAssertEqual(c.cS2RC("tij"), "ㄊㄧˇ")
+    XCTAssertEqual(c.cS2RC("til"), "ㄊㄧˋ")
+    XCTAssertEqual(c.cS2RC("tie"), "ㄊㄧㄝ")
+    XCTAssertEqual(c.cS2RC("tief"), "ㄊㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("tiej"), "ㄊㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("tiel"), "ㄊㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("tiw"), "ㄊㄧㄠ")
+    XCTAssertEqual(c.cS2RC("tiwf"), "ㄊㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("tiwj"), "ㄊㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("tiwl"), "ㄊㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("tib"), "ㄊㄧㄢ")
+    XCTAssertEqual(c.cS2RC("tibf"), "ㄊㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("tibj"), "ㄊㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("tibl"), "ㄊㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("tim"), "ㄊㄧㄥ")
+    XCTAssertEqual(c.cS2RC("timf"), "ㄊㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("timj"), "ㄊㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("timl"), "ㄊㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("tu"), "ㄊㄨ")
+    XCTAssertEqual(c.cS2RC("tuf"), "ㄊㄨˊ")
+    XCTAssertEqual(c.cS2RC("tuj"), "ㄊㄨˇ")
+    XCTAssertEqual(c.cS2RC("tul"), "ㄊㄨˋ")
+    XCTAssertEqual(c.cS2RC("tuo"), "ㄊㄨㄛ")
+    XCTAssertEqual(c.cS2RC("tuof"), "ㄊㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("tuoj"), "ㄊㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("tuol"), "ㄊㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("tuk"), "ㄊㄨㄟ")
+    XCTAssertEqual(c.cS2RC("tukf"), "ㄊㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("tukj"), "ㄊㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("tukl"), "ㄊㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("tub"), "ㄊㄨㄢ")
+    XCTAssertEqual(c.cS2RC("tubf"), "ㄊㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("tubj"), "ㄊㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("tubl"), "ㄊㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("tun"), "ㄊㄨㄣ")
+    XCTAssertEqual(c.cS2RC("tunf"), "ㄊㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("tunj"), "ㄊㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("tunl"), "ㄊㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("tum"), "ㄊㄨㄥ")
+    XCTAssertEqual(c.cS2RC("tumf"), "ㄊㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("tumj"), "ㄊㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("tuml"), "ㄊㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("na"), "ㄋㄚ")
+    XCTAssertEqual(c.cS2RC("naf"), "ㄋㄚˊ")
+    XCTAssertEqual(c.cS2RC("naj"), "ㄋㄚˇ")
+    XCTAssertEqual(c.cS2RC("nal"), "ㄋㄚˋ")
+    XCTAssertEqual(c.cS2RC("nad"), "ㄋㄚ˙")
+    XCTAssertEqual(c.cS2RC("nel"), "ㄋㄜˋ")
+    XCTAssertEqual(c.cS2RC("ned"), "ㄋㄜ˙")
+    XCTAssertEqual(c.cS2RC("nhf"), "ㄋㄞˊ")
+    XCTAssertEqual(c.cS2RC("nhj"), "ㄋㄞˇ")
+    XCTAssertEqual(c.cS2RC("nhl"), "ㄋㄞˋ")
+    XCTAssertEqual(c.cS2RC("nkf"), "ㄋㄟˊ")
+    XCTAssertEqual(c.cS2RC("nkj"), "ㄋㄟˇ")
+    XCTAssertEqual(c.cS2RC("nkl"), "ㄋㄟˋ")
+    XCTAssertEqual(c.cS2RC("nw"), "ㄋㄠ")
+    XCTAssertEqual(c.cS2RC("nwf"), "ㄋㄠˊ")
+    XCTAssertEqual(c.cS2RC("nwj"), "ㄋㄠˇ")
+    XCTAssertEqual(c.cS2RC("nwl"), "ㄋㄠˋ")
+    XCTAssertEqual(c.cS2RC("nvf"), "ㄋㄡˊ")
+    XCTAssertEqual(c.cS2RC("nvj"), "ㄋㄡˇ")
+    XCTAssertEqual(c.cS2RC("nvl"), "ㄋㄡˋ")
+    XCTAssertEqual(c.cS2RC("nb"), "ㄋㄢ")
+    XCTAssertEqual(c.cS2RC("nbf"), "ㄋㄢˊ")
+    XCTAssertEqual(c.cS2RC("nbj"), "ㄋㄢˇ")
+    XCTAssertEqual(c.cS2RC("nbl"), "ㄋㄢˋ")
+    XCTAssertEqual(c.cS2RC("nnj"), "ㄋㄣˇ")
+    XCTAssertEqual(c.cS2RC("nnl"), "ㄋㄣˋ")
+    XCTAssertEqual(c.cS2RC("ng"), "ㄋㄤ")
+    XCTAssertEqual(c.cS2RC("ngf"), "ㄋㄤˊ")
+    XCTAssertEqual(c.cS2RC("ngj"), "ㄋㄤˇ")
+    XCTAssertEqual(c.cS2RC("ngl"), "ㄋㄤˋ")
+    XCTAssertEqual(c.cS2RC("ngd"), "ㄋㄤ˙")
+    XCTAssertEqual(c.cS2RC("nmf"), "ㄋㄥˊ")
+    XCTAssertEqual(c.cS2RC("nmj"), "ㄋㄥˇ")
+    XCTAssertEqual(c.cS2RC("ni"), "ㄋㄧ")
+    XCTAssertEqual(c.cS2RC("nif"), "ㄋㄧˊ")
+    XCTAssertEqual(c.cS2RC("nij"), "ㄋㄧˇ")
+    XCTAssertEqual(c.cS2RC("nil"), "ㄋㄧˋ")
+    XCTAssertEqual(c.cS2RC("nie"), "ㄋㄧㄝ")
+    XCTAssertEqual(c.cS2RC("nief"), "ㄋㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("niel"), "ㄋㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("niwj"), "ㄋㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("niwl"), "ㄋㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("niv"), "ㄋㄧㄡ")
+    XCTAssertEqual(c.cS2RC("nivf"), "ㄋㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("nivj"), "ㄋㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("nivl"), "ㄋㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("nib"), "ㄋㄧㄢ")
+    XCTAssertEqual(c.cS2RC("nibf"), "ㄋㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("nibj"), "ㄋㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("nibl"), "ㄋㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("nin"), "ㄋㄧㄣ")
+    XCTAssertEqual(c.cS2RC("ninf"), "ㄋㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("ninj"), "ㄋㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("ninl"), "ㄋㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("nigf"), "ㄋㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("nigj"), "ㄋㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("nigl"), "ㄋㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("nimf"), "ㄋㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("nimj"), "ㄋㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("niml"), "ㄋㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("nuf"), "ㄋㄨˊ")
+    XCTAssertEqual(c.cS2RC("nuj"), "ㄋㄨˇ")
+    XCTAssertEqual(c.cS2RC("nul"), "ㄋㄨˋ")
+    XCTAssertEqual(c.cS2RC("nuof"), "ㄋㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("nuoj"), "ㄋㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("nuol"), "ㄋㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("nukf"), "ㄋㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("nubf"), "ㄋㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("nubj"), "ㄋㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("nubl"), "ㄋㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("nunf"), "ㄋㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("numf"), "ㄋㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("numj"), "ㄋㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("numl"), "ㄋㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("nyf"), "ㄋㄩˊ")
+    XCTAssertEqual(c.cS2RC("nyj"), "ㄋㄩˇ")
+    XCTAssertEqual(c.cS2RC("nyl"), "ㄋㄩˋ")
+    XCTAssertEqual(c.cS2RC("nyel"), "ㄋㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("la"), "ㄌㄚ")
+    XCTAssertEqual(c.cS2RC("laf"), "ㄌㄚˊ")
+    XCTAssertEqual(c.cS2RC("laj"), "ㄌㄚˇ")
+    XCTAssertEqual(c.cS2RC("lal"), "ㄌㄚˋ")
+    XCTAssertEqual(c.cS2RC("lad"), "ㄌㄚ˙")
+    XCTAssertEqual(c.cS2RC("lo"), "ㄌㄛ")
+    XCTAssertEqual(c.cS2RC("lod"), "ㄌㄛ˙")
+    XCTAssertEqual(c.cS2RC("le"), "ㄌㄜ")
+    XCTAssertEqual(c.cS2RC("lef"), "ㄌㄜˊ")
+    XCTAssertEqual(c.cS2RC("lel"), "ㄌㄜˋ")
+    XCTAssertEqual(c.cS2RC("led"), "ㄌㄜ˙")
+    XCTAssertEqual(c.cS2RC("lhf"), "ㄌㄞˊ")
+    XCTAssertEqual(c.cS2RC("lhj"), "ㄌㄞˇ")
+    XCTAssertEqual(c.cS2RC("lhl"), "ㄌㄞˋ")
+    XCTAssertEqual(c.cS2RC("lk"), "ㄌㄟ")
+    XCTAssertEqual(c.cS2RC("lkf"), "ㄌㄟˊ")
+    XCTAssertEqual(c.cS2RC("lkj"), "ㄌㄟˇ")
+    XCTAssertEqual(c.cS2RC("lkl"), "ㄌㄟˋ")
+    XCTAssertEqual(c.cS2RC("lkd"), "ㄌㄟ˙")
+  }
+}

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_B.swift

@@ -0,0 +1,501 @@
+// (c) 2022 and onwards The vChewing Project (MIT-NTL License).
+// ====================
+// This code is released under the MIT license (SPDX-License-Identifier: MIT)
+// ... with NTL restriction stating that:
+// No trademark license is granted to use the trade names, trademarks, service
+// marks, or product names of Contributor, except as required to fulfill notice
+// requirements defined in MIT License.
+
+import XCTest
+
+@testable import Tekkon
+
+extension TekkonTestsKeyboardArrangments {
+  func testAlvinLiuKeysB() throws {
+    var c = Tekkon.Composer(arrange: .ofAlvinLiu)
+    XCTAssertEqual(c.cS2RC("lw"), "ㄌㄠ")
+    XCTAssertEqual(c.cS2RC("lwf"), "ㄌㄠˊ")
+    XCTAssertEqual(c.cS2RC("lwj"), "ㄌㄠˇ")
+    XCTAssertEqual(c.cS2RC("lwl"), "ㄌㄠˋ")
+    XCTAssertEqual(c.cS2RC("lv"), "ㄌㄡ")
+    XCTAssertEqual(c.cS2RC("lvf"), "ㄌㄡˊ")
+    XCTAssertEqual(c.cS2RC("lvj"), "ㄌㄡˇ")
+    XCTAssertEqual(c.cS2RC("lvl"), "ㄌㄡˋ")
+    XCTAssertEqual(c.cS2RC("lvd"), "ㄌㄡ˙")
+    XCTAssertEqual(c.cS2RC("lbf"), "ㄌㄢˊ")
+    XCTAssertEqual(c.cS2RC("lbj"), "ㄌㄢˇ")
+    XCTAssertEqual(c.cS2RC("lbl"), "ㄌㄢˋ")
+    XCTAssertEqual(c.cS2RC("lg"), "ㄌㄤ")
+    XCTAssertEqual(c.cS2RC("lgf"), "ㄌㄤˊ")
+    XCTAssertEqual(c.cS2RC("lgj"), "ㄌㄤˇ")
+    XCTAssertEqual(c.cS2RC("lgl"), "ㄌㄤˋ")
+    XCTAssertEqual(c.cS2RC("lm"), "ㄌㄥ")
+    XCTAssertEqual(c.cS2RC("lmf"), "ㄌㄥˊ")
+    XCTAssertEqual(c.cS2RC("lmj"), "ㄌㄥˇ")
+    XCTAssertEqual(c.cS2RC("lml"), "ㄌㄥˋ")
+    XCTAssertEqual(c.cS2RC("li"), "ㄌㄧ")
+    XCTAssertEqual(c.cS2RC("lif"), "ㄌㄧˊ")
+    XCTAssertEqual(c.cS2RC("lij"), "ㄌㄧˇ")
+    XCTAssertEqual(c.cS2RC("lil"), "ㄌㄧˋ")
+    XCTAssertEqual(c.cS2RC("lid"), "ㄌㄧ˙")
+    XCTAssertEqual(c.cS2RC("liaj"), "ㄌㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("lie"), "ㄌㄧㄝ")
+    XCTAssertEqual(c.cS2RC("lief"), "ㄌㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("liej"), "ㄌㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("liel"), "ㄌㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("liw"), "ㄌㄧㄠ")
+    XCTAssertEqual(c.cS2RC("liwf"), "ㄌㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("liwj"), "ㄌㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("liwl"), "ㄌㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("liv"), "ㄌㄧㄡ")
+    XCTAssertEqual(c.cS2RC("livf"), "ㄌㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("livj"), "ㄌㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("livl"), "ㄌㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("lib"), "ㄌㄧㄢ")
+    XCTAssertEqual(c.cS2RC("libf"), "ㄌㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("libj"), "ㄌㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("libl"), "ㄌㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("linf"), "ㄌㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("linj"), "ㄌㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("linl"), "ㄌㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("ligf"), "ㄌㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("ligj"), "ㄌㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("ligl"), "ㄌㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("lim"), "ㄌㄧㄥ")
+    XCTAssertEqual(c.cS2RC("limf"), "ㄌㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("limj"), "ㄌㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("liml"), "ㄌㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("lu"), "ㄌㄨ")
+    XCTAssertEqual(c.cS2RC("luf"), "ㄌㄨˊ")
+    XCTAssertEqual(c.cS2RC("luj"), "ㄌㄨˇ")
+    XCTAssertEqual(c.cS2RC("lul"), "ㄌㄨˋ")
+    XCTAssertEqual(c.cS2RC("luo"), "ㄌㄨㄛ")
+    XCTAssertEqual(c.cS2RC("luof"), "ㄌㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("luoj"), "ㄌㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("luol"), "ㄌㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("luod"), "ㄌㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("lubf"), "ㄌㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("lubj"), "ㄌㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("lubl"), "ㄌㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("lun"), "ㄌㄨㄣ")
+    XCTAssertEqual(c.cS2RC("lunf"), "ㄌㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("lunj"), "ㄌㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("lunl"), "ㄌㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("lum"), "ㄌㄨㄥ")
+    XCTAssertEqual(c.cS2RC("lumf"), "ㄌㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("lumj"), "ㄌㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("luml"), "ㄌㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("ly"), "ㄌㄩ")
+    XCTAssertEqual(c.cS2RC("lyf"), "ㄌㄩˊ")
+    XCTAssertEqual(c.cS2RC("lyj"), "ㄌㄩˇ")
+    XCTAssertEqual(c.cS2RC("lyl"), "ㄌㄩˋ")
+    XCTAssertEqual(c.cS2RC("lye"), "ㄌㄩㄝ")
+    XCTAssertEqual(c.cS2RC("lyej"), "ㄌㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("lyel"), "ㄌㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("lybf"), "ㄌㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("lybj"), "ㄌㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("ga"), "ㄍㄚ")
+    XCTAssertEqual(c.cS2RC("gaf"), "ㄍㄚˊ")
+    XCTAssertEqual(c.cS2RC("gaj"), "ㄍㄚˇ")
+    XCTAssertEqual(c.cS2RC("gal"), "ㄍㄚˋ")
+    XCTAssertEqual(c.cS2RC("gad"), "ㄍㄚ˙")
+    XCTAssertEqual(c.cS2RC("ge"), "ㄍㄜ")
+    XCTAssertEqual(c.cS2RC("gef"), "ㄍㄜˊ")
+    XCTAssertEqual(c.cS2RC("gej"), "ㄍㄜˇ")
+    XCTAssertEqual(c.cS2RC("gel"), "ㄍㄜˋ")
+    XCTAssertEqual(c.cS2RC("ged"), "ㄍㄜ˙")
+    XCTAssertEqual(c.cS2RC("gh"), "ㄍㄞ")
+    XCTAssertEqual(c.cS2RC("ghj"), "ㄍㄞˇ")
+    XCTAssertEqual(c.cS2RC("ghl"), "ㄍㄞˋ")
+    XCTAssertEqual(c.cS2RC("gkj"), "ㄍㄟˇ")
+    XCTAssertEqual(c.cS2RC("gw"), "ㄍㄠ")
+    XCTAssertEqual(c.cS2RC("gwj"), "ㄍㄠˇ")
+    XCTAssertEqual(c.cS2RC("gwl"), "ㄍㄠˋ")
+    XCTAssertEqual(c.cS2RC("gv"), "ㄍㄡ")
+    XCTAssertEqual(c.cS2RC("gvj"), "ㄍㄡˇ")
+    XCTAssertEqual(c.cS2RC("gvl"), "ㄍㄡˋ")
+    XCTAssertEqual(c.cS2RC("gb"), "ㄍㄢ")
+    XCTAssertEqual(c.cS2RC("gbj"), "ㄍㄢˇ")
+    XCTAssertEqual(c.cS2RC("gbl"), "ㄍㄢˋ")
+    XCTAssertEqual(c.cS2RC("gn"), "ㄍㄣ")
+    XCTAssertEqual(c.cS2RC("gnf"), "ㄍㄣˊ")
+    XCTAssertEqual(c.cS2RC("gnj"), "ㄍㄣˇ")
+    XCTAssertEqual(c.cS2RC("gnl"), "ㄍㄣˋ")
+    XCTAssertEqual(c.cS2RC("gg"), "ㄍㄤ")
+    XCTAssertEqual(c.cS2RC("ggj"), "ㄍㄤˇ")
+    XCTAssertEqual(c.cS2RC("ggl"), "ㄍㄤˋ")
+    XCTAssertEqual(c.cS2RC("gm"), "ㄍㄥ")
+    XCTAssertEqual(c.cS2RC("gmj"), "ㄍㄥˇ")
+    XCTAssertEqual(c.cS2RC("gml"), "ㄍㄥˋ")
+    XCTAssertEqual(c.cS2RC("gu"), "ㄍㄨ")
+    XCTAssertEqual(c.cS2RC("guf"), "ㄍㄨˊ")
+    XCTAssertEqual(c.cS2RC("guj"), "ㄍㄨˇ")
+    XCTAssertEqual(c.cS2RC("gul"), "ㄍㄨˋ")
+    XCTAssertEqual(c.cS2RC("gua"), "ㄍㄨㄚ")
+    XCTAssertEqual(c.cS2RC("guaf"), "ㄍㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("guaj"), "ㄍㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("gual"), "ㄍㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("guo"), "ㄍㄨㄛ")
+    XCTAssertEqual(c.cS2RC("guof"), "ㄍㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("guoj"), "ㄍㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("guol"), "ㄍㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("guh"), "ㄍㄨㄞ")
+    XCTAssertEqual(c.cS2RC("guhj"), "ㄍㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("guhl"), "ㄍㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("guk"), "ㄍㄨㄟ")
+    XCTAssertEqual(c.cS2RC("gukj"), "ㄍㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("gukl"), "ㄍㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("gub"), "ㄍㄨㄢ")
+    XCTAssertEqual(c.cS2RC("gubj"), "ㄍㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("gubl"), "ㄍㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("gun"), "ㄍㄨㄣ")
+    XCTAssertEqual(c.cS2RC("gunj"), "ㄍㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("gunl"), "ㄍㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("gug"), "ㄍㄨㄤ")
+    XCTAssertEqual(c.cS2RC("gugj"), "ㄍㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("gugl"), "ㄍㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("gum"), "ㄍㄨㄥ")
+    XCTAssertEqual(c.cS2RC("gumf"), "ㄍㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("gumj"), "ㄍㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("guml"), "ㄍㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("ka"), "ㄎㄚ")
+    XCTAssertEqual(c.cS2RC("kaj"), "ㄎㄚˇ")
+    XCTAssertEqual(c.cS2RC("kal"), "ㄎㄚˋ")
+    XCTAssertEqual(c.cS2RC("ke"), "ㄎㄜ")
+    XCTAssertEqual(c.cS2RC("kef"), "ㄎㄜˊ")
+    XCTAssertEqual(c.cS2RC("kej"), "ㄎㄜˇ")
+    XCTAssertEqual(c.cS2RC("kel"), "ㄎㄜˋ")
+    XCTAssertEqual(c.cS2RC("kh"), "ㄎㄞ")
+    XCTAssertEqual(c.cS2RC("khj"), "ㄎㄞˇ")
+    XCTAssertEqual(c.cS2RC("khl"), "ㄎㄞˋ")
+    XCTAssertEqual(c.cS2RC("kw"), "ㄎㄠ")
+    XCTAssertEqual(c.cS2RC("kwj"), "ㄎㄠˇ")
+    XCTAssertEqual(c.cS2RC("kwl"), "ㄎㄠˋ")
+    XCTAssertEqual(c.cS2RC("kv"), "ㄎㄡ")
+    XCTAssertEqual(c.cS2RC("kvj"), "ㄎㄡˇ")
+    XCTAssertEqual(c.cS2RC("kvl"), "ㄎㄡˋ")
+    XCTAssertEqual(c.cS2RC("kb"), "ㄎㄢ")
+    XCTAssertEqual(c.cS2RC("kbj"), "ㄎㄢˇ")
+    XCTAssertEqual(c.cS2RC("kbl"), "ㄎㄢˋ")
+    XCTAssertEqual(c.cS2RC("kn"), "ㄎㄣ")
+    XCTAssertEqual(c.cS2RC("knj"), "ㄎㄣˇ")
+    XCTAssertEqual(c.cS2RC("knl"), "ㄎㄣˋ")
+    XCTAssertEqual(c.cS2RC("kg"), "ㄎㄤ")
+    XCTAssertEqual(c.cS2RC("kgf"), "ㄎㄤˊ")
+    XCTAssertEqual(c.cS2RC("kgj"), "ㄎㄤˇ")
+    XCTAssertEqual(c.cS2RC("kgl"), "ㄎㄤˋ")
+    XCTAssertEqual(c.cS2RC("km"), "ㄎㄥ")
+    XCTAssertEqual(c.cS2RC("kmj"), "ㄎㄥˇ")
+    XCTAssertEqual(c.cS2RC("ku"), "ㄎㄨ")
+    XCTAssertEqual(c.cS2RC("kuf"), "ㄎㄨˊ")
+    XCTAssertEqual(c.cS2RC("kuj"), "ㄎㄨˇ")
+    XCTAssertEqual(c.cS2RC("kul"), "ㄎㄨˋ")
+    XCTAssertEqual(c.cS2RC("kua"), "ㄎㄨㄚ")
+    XCTAssertEqual(c.cS2RC("kuaj"), "ㄎㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("kual"), "ㄎㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("kuol"), "ㄎㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("kuh"), "ㄎㄨㄞ")
+    XCTAssertEqual(c.cS2RC("kuhj"), "ㄎㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("kuhl"), "ㄎㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("kuk"), "ㄎㄨㄟ")
+    XCTAssertEqual(c.cS2RC("kukf"), "ㄎㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("kukj"), "ㄎㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("kukl"), "ㄎㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("kub"), "ㄎㄨㄢ")
+    XCTAssertEqual(c.cS2RC("kubj"), "ㄎㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("kubl"), "ㄎㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("kun"), "ㄎㄨㄣ")
+    XCTAssertEqual(c.cS2RC("kunj"), "ㄎㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("kunl"), "ㄎㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("kug"), "ㄎㄨㄤ")
+    XCTAssertEqual(c.cS2RC("kugf"), "ㄎㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("kugj"), "ㄎㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("kugl"), "ㄎㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("kum"), "ㄎㄨㄥ")
+    XCTAssertEqual(c.cS2RC("kumj"), "ㄎㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("kuml"), "ㄎㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("ha"), "ㄏㄚ")
+    XCTAssertEqual(c.cS2RC("haf"), "ㄏㄚˊ")
+    XCTAssertEqual(c.cS2RC("haj"), "ㄏㄚˇ")
+    XCTAssertEqual(c.cS2RC("he"), "ㄏㄜ")
+    XCTAssertEqual(c.cS2RC("hef"), "ㄏㄜˊ")
+    XCTAssertEqual(c.cS2RC("hej"), "ㄏㄜˇ")
+    XCTAssertEqual(c.cS2RC("hel"), "ㄏㄜˋ")
+    XCTAssertEqual(c.cS2RC("hh"), "ㄏㄞ")
+    XCTAssertEqual(c.cS2RC("hhf"), "ㄏㄞˊ")
+    XCTAssertEqual(c.cS2RC("hhj"), "ㄏㄞˇ")
+    XCTAssertEqual(c.cS2RC("hhl"), "ㄏㄞˋ")
+    XCTAssertEqual(c.cS2RC("hk"), "ㄏㄟ")
+    XCTAssertEqual(c.cS2RC("hkj"), "ㄏㄟˇ")
+    XCTAssertEqual(c.cS2RC("hw"), "ㄏㄠ")
+    XCTAssertEqual(c.cS2RC("hwf"), "ㄏㄠˊ")
+    XCTAssertEqual(c.cS2RC("hwj"), "ㄏㄠˇ")
+    XCTAssertEqual(c.cS2RC("hwl"), "ㄏㄠˋ")
+    XCTAssertEqual(c.cS2RC("hv"), "ㄏㄡ")
+    XCTAssertEqual(c.cS2RC("hvf"), "ㄏㄡˊ")
+    XCTAssertEqual(c.cS2RC("hvj"), "ㄏㄡˇ")
+    XCTAssertEqual(c.cS2RC("hvl"), "ㄏㄡˋ")
+    XCTAssertEqual(c.cS2RC("hb"), "ㄏㄢ")
+    XCTAssertEqual(c.cS2RC("hbf"), "ㄏㄢˊ")
+    XCTAssertEqual(c.cS2RC("hbj"), "ㄏㄢˇ")
+    XCTAssertEqual(c.cS2RC("hbl"), "ㄏㄢˋ")
+    XCTAssertEqual(c.cS2RC("hn"), "ㄏㄣ")
+    XCTAssertEqual(c.cS2RC("hnf"), "ㄏㄣˊ")
+    XCTAssertEqual(c.cS2RC("hnj"), "ㄏㄣˇ")
+    XCTAssertEqual(c.cS2RC("hnl"), "ㄏㄣˋ")
+    XCTAssertEqual(c.cS2RC("hg"), "ㄏㄤ")
+    XCTAssertEqual(c.cS2RC("hgf"), "ㄏㄤˊ")
+    XCTAssertEqual(c.cS2RC("hgj"), "ㄏㄤˇ")
+    XCTAssertEqual(c.cS2RC("hgl"), "ㄏㄤˋ")
+    XCTAssertEqual(c.cS2RC("hm"), "ㄏㄥ")
+    XCTAssertEqual(c.cS2RC("hmf"), "ㄏㄥˊ")
+    XCTAssertEqual(c.cS2RC("hml"), "ㄏㄥˋ")
+    XCTAssertEqual(c.cS2RC("hu"), "ㄏㄨ")
+    XCTAssertEqual(c.cS2RC("huf"), "ㄏㄨˊ")
+    XCTAssertEqual(c.cS2RC("huj"), "ㄏㄨˇ")
+    XCTAssertEqual(c.cS2RC("hul"), "ㄏㄨˋ")
+    XCTAssertEqual(c.cS2RC("hua"), "ㄏㄨㄚ")
+    XCTAssertEqual(c.cS2RC("huaf"), "ㄏㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("huaj"), "ㄏㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("hual"), "ㄏㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("huo"), "ㄏㄨㄛ")
+    XCTAssertEqual(c.cS2RC("huof"), "ㄏㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("huoj"), "ㄏㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("huol"), "ㄏㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("huod"), "ㄏㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("huhf"), "ㄏㄨㄞˊ")
+    XCTAssertEqual(c.cS2RC("huhl"), "ㄏㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("huk"), "ㄏㄨㄟ")
+    XCTAssertEqual(c.cS2RC("hukf"), "ㄏㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("hukj"), "ㄏㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("hukl"), "ㄏㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("hub"), "ㄏㄨㄢ")
+    XCTAssertEqual(c.cS2RC("hubf"), "ㄏㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("hubj"), "ㄏㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("hubl"), "ㄏㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("hun"), "ㄏㄨㄣ")
+    XCTAssertEqual(c.cS2RC("hunf"), "ㄏㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("hunj"), "ㄏㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("hunl"), "ㄏㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("hug"), "ㄏㄨㄤ")
+    XCTAssertEqual(c.cS2RC("hugf"), "ㄏㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("hugj"), "ㄏㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("hugl"), "ㄏㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("hugd"), "ㄏㄨㄤ˙")
+    XCTAssertEqual(c.cS2RC("hum"), "ㄏㄨㄥ")
+    XCTAssertEqual(c.cS2RC("humf"), "ㄏㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("humj"), "ㄏㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("huml"), "ㄏㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("ji"), "ㄐㄧ")
+    XCTAssertEqual(c.cS2RC("jif"), "ㄐㄧˊ")
+    XCTAssertEqual(c.cS2RC("jij"), "ㄐㄧˇ")
+    XCTAssertEqual(c.cS2RC("jil"), "ㄐㄧˋ")
+    XCTAssertEqual(c.cS2RC("jia"), "ㄐㄧㄚ")
+    XCTAssertEqual(c.cS2RC("jiaf"), "ㄐㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("jiaj"), "ㄐㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("jial"), "ㄐㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("jie"), "ㄐㄧㄝ")
+    XCTAssertEqual(c.cS2RC("jief"), "ㄐㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("jiej"), "ㄐㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("jiel"), "ㄐㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("jied"), "ㄐㄧㄝ˙")
+    XCTAssertEqual(c.cS2RC("jiw"), "ㄐㄧㄠ")
+    XCTAssertEqual(c.cS2RC("jiwf"), "ㄐㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("jiwj"), "ㄐㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("jiwl"), "ㄐㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("jiv"), "ㄐㄧㄡ")
+    XCTAssertEqual(c.cS2RC("jivj"), "ㄐㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("jivl"), "ㄐㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("jib"), "ㄐㄧㄢ")
+    XCTAssertEqual(c.cS2RC("jibj"), "ㄐㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("jibl"), "ㄐㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("jin"), "ㄐㄧㄣ")
+    XCTAssertEqual(c.cS2RC("jinj"), "ㄐㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("jinl"), "ㄐㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("jig"), "ㄐㄧㄤ")
+    XCTAssertEqual(c.cS2RC("jigf"), "ㄐㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("jigj"), "ㄐㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("jigl"), "ㄐㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("jim"), "ㄐㄧㄥ")
+    XCTAssertEqual(c.cS2RC("jimj"), "ㄐㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("jiml"), "ㄐㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("jy"), "ㄐㄩ")
+    XCTAssertEqual(c.cS2RC("jyf"), "ㄐㄩˊ")
+    XCTAssertEqual(c.cS2RC("jyj"), "ㄐㄩˇ")
+    XCTAssertEqual(c.cS2RC("jyl"), "ㄐㄩˋ")
+    XCTAssertEqual(c.cS2RC("jye"), "ㄐㄩㄝ")
+    XCTAssertEqual(c.cS2RC("jyef"), "ㄐㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("jyej"), "ㄐㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("jyel"), "ㄐㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("jyb"), "ㄐㄩㄢ")
+    XCTAssertEqual(c.cS2RC("jybj"), "ㄐㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("jybl"), "ㄐㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("jyn"), "ㄐㄩㄣ")
+    XCTAssertEqual(c.cS2RC("jynf"), "ㄐㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("jynj"), "ㄐㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("jynl"), "ㄐㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("jym"), "ㄐㄩㄥ")
+    XCTAssertEqual(c.cS2RC("jymj"), "ㄐㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("jyml"), "ㄐㄩㄥˋ")
+    // XCTAssertEqual(c.cS2RC("qd"), "ㄑ˙")
+    XCTAssertEqual(c.cS2RC("qi"), "ㄑㄧ")
+    XCTAssertEqual(c.cS2RC("qif"), "ㄑㄧˊ")
+    XCTAssertEqual(c.cS2RC("qij"), "ㄑㄧˇ")
+    XCTAssertEqual(c.cS2RC("qil"), "ㄑㄧˋ")
+    XCTAssertEqual(c.cS2RC("qia"), "ㄑㄧㄚ")
+    XCTAssertEqual(c.cS2RC("qiaf"), "ㄑㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("qiaj"), "ㄑㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("qial"), "ㄑㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("qie"), "ㄑㄧㄝ")
+    XCTAssertEqual(c.cS2RC("qief"), "ㄑㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("qiej"), "ㄑㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("qiel"), "ㄑㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("qiw"), "ㄑㄧㄠ")
+    XCTAssertEqual(c.cS2RC("qiwf"), "ㄑㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("qiwj"), "ㄑㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("qiwl"), "ㄑㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("qiv"), "ㄑㄧㄡ")
+    XCTAssertEqual(c.cS2RC("qivf"), "ㄑㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("qivj"), "ㄑㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("qivl"), "ㄑㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("qib"), "ㄑㄧㄢ")
+    XCTAssertEqual(c.cS2RC("qibf"), "ㄑㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("qibj"), "ㄑㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("qibl"), "ㄑㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("qin"), "ㄑㄧㄣ")
+    XCTAssertEqual(c.cS2RC("qinf"), "ㄑㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("qinj"), "ㄑㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("qinl"), "ㄑㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("qig"), "ㄑㄧㄤ")
+    XCTAssertEqual(c.cS2RC("qigf"), "ㄑㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("qigj"), "ㄑㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("qigl"), "ㄑㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("qim"), "ㄑㄧㄥ")
+    XCTAssertEqual(c.cS2RC("qimf"), "ㄑㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("qimj"), "ㄑㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("qiml"), "ㄑㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("qy"), "ㄑㄩ")
+    XCTAssertEqual(c.cS2RC("qyf"), "ㄑㄩˊ")
+    XCTAssertEqual(c.cS2RC("qyj"), "ㄑㄩˇ")
+    XCTAssertEqual(c.cS2RC("qyl"), "ㄑㄩˋ")
+    XCTAssertEqual(c.cS2RC("qye"), "ㄑㄩㄝ")
+    XCTAssertEqual(c.cS2RC("qyef"), "ㄑㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("qyel"), "ㄑㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("qyb"), "ㄑㄩㄢ")
+    XCTAssertEqual(c.cS2RC("qybf"), "ㄑㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("qybj"), "ㄑㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("qybl"), "ㄑㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("qyn"), "ㄑㄩㄣ")
+    XCTAssertEqual(c.cS2RC("qynf"), "ㄑㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("qynj"), "ㄑㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("qynl"), "ㄑㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("qym"), "ㄑㄩㄥ")
+    XCTAssertEqual(c.cS2RC("qymf"), "ㄑㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("qymj"), "ㄑㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("qyml"), "ㄑㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("xi"), "ㄒㄧ")
+    XCTAssertEqual(c.cS2RC("xif"), "ㄒㄧˊ")
+    XCTAssertEqual(c.cS2RC("xij"), "ㄒㄧˇ")
+    XCTAssertEqual(c.cS2RC("xil"), "ㄒㄧˋ")
+    XCTAssertEqual(c.cS2RC("xia"), "ㄒㄧㄚ")
+    XCTAssertEqual(c.cS2RC("xiaf"), "ㄒㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("xiaj"), "ㄒㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("xial"), "ㄒㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("xie"), "ㄒㄧㄝ")
+    XCTAssertEqual(c.cS2RC("xief"), "ㄒㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("xiej"), "ㄒㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("xiel"), "ㄒㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("xiw"), "ㄒㄧㄠ")
+    XCTAssertEqual(c.cS2RC("xiwf"), "ㄒㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("xiwj"), "ㄒㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("xiwl"), "ㄒㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("xiv"), "ㄒㄧㄡ")
+    XCTAssertEqual(c.cS2RC("xivf"), "ㄒㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("xivj"), "ㄒㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("xivl"), "ㄒㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("xib"), "ㄒㄧㄢ")
+    XCTAssertEqual(c.cS2RC("xibf"), "ㄒㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("xibj"), "ㄒㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("xibl"), "ㄒㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("xin"), "ㄒㄧㄣ")
+    XCTAssertEqual(c.cS2RC("xinf"), "ㄒㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("xinj"), "ㄒㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("xinl"), "ㄒㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("xig"), "ㄒㄧㄤ")
+    XCTAssertEqual(c.cS2RC("xigf"), "ㄒㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("xigj"), "ㄒㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("xigl"), "ㄒㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("xim"), "ㄒㄧㄥ")
+    XCTAssertEqual(c.cS2RC("ximf"), "ㄒㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("ximj"), "ㄒㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("ximl"), "ㄒㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("xy"), "ㄒㄩ")
+    XCTAssertEqual(c.cS2RC("xyf"), "ㄒㄩˊ")
+    XCTAssertEqual(c.cS2RC("xyj"), "ㄒㄩˇ")
+    XCTAssertEqual(c.cS2RC("xyl"), "ㄒㄩˋ")
+    XCTAssertEqual(c.cS2RC("xye"), "ㄒㄩㄝ")
+    XCTAssertEqual(c.cS2RC("xyef"), "ㄒㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("xyej"), "ㄒㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("xyel"), "ㄒㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("xyb"), "ㄒㄩㄢ")
+    XCTAssertEqual(c.cS2RC("xybf"), "ㄒㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("xybj"), "ㄒㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("xybl"), "ㄒㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("xyn"), "ㄒㄩㄣ")
+    XCTAssertEqual(c.cS2RC("xynf"), "ㄒㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("xynl"), "ㄒㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("xym"), "ㄒㄩㄥ")
+    XCTAssertEqual(c.cS2RC("xymf"), "ㄒㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("xymj"), "ㄒㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("xyml"), "ㄒㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("j"), "ㄓ")
+    XCTAssertEqual(c.cS2RC("jf"), "ㄓˊ")
+    XCTAssertEqual(c.cS2RC("jj"), "ㄓˇ")
+    XCTAssertEqual(c.cS2RC("jl"), "ㄓˋ")
+    XCTAssertEqual(c.cS2RC("ja"), "ㄓㄚ")
+    XCTAssertEqual(c.cS2RC("jaf"), "ㄓㄚˊ")
+    XCTAssertEqual(c.cS2RC("jaj"), "ㄓㄚˇ")
+    XCTAssertEqual(c.cS2RC("jal"), "ㄓㄚˋ")
+    XCTAssertEqual(c.cS2RC("je"), "ㄓㄜ")
+    XCTAssertEqual(c.cS2RC("jef"), "ㄓㄜˊ")
+    XCTAssertEqual(c.cS2RC("jej"), "ㄓㄜˇ")
+    XCTAssertEqual(c.cS2RC("jel"), "ㄓㄜˋ")
+    XCTAssertEqual(c.cS2RC("jed"), "ㄓㄜ˙")
+    XCTAssertEqual(c.cS2RC("jh"), "ㄓㄞ")
+    XCTAssertEqual(c.cS2RC("jhf"), "ㄓㄞˊ")
+    XCTAssertEqual(c.cS2RC("jhj"), "ㄓㄞˇ")
+    XCTAssertEqual(c.cS2RC("jhl"), "ㄓㄞˋ")
+    XCTAssertEqual(c.cS2RC("jkl"), "ㄓㄟˋ")
+    XCTAssertEqual(c.cS2RC("jw"), "ㄓㄠ")
+    XCTAssertEqual(c.cS2RC("jwf"), "ㄓㄠˊ")
+    XCTAssertEqual(c.cS2RC("jwj"), "ㄓㄠˇ")
+    XCTAssertEqual(c.cS2RC("jwl"), "ㄓㄠˋ")
+    XCTAssertEqual(c.cS2RC("jv"), "ㄓㄡ")
+    XCTAssertEqual(c.cS2RC("jvf"), "ㄓㄡˊ")
+    XCTAssertEqual(c.cS2RC("jvj"), "ㄓㄡˇ")
+    XCTAssertEqual(c.cS2RC("jvl"), "ㄓㄡˋ")
+    XCTAssertEqual(c.cS2RC("jb"), "ㄓㄢ")
+    XCTAssertEqual(c.cS2RC("jbj"), "ㄓㄢˇ")
+    XCTAssertEqual(c.cS2RC("jbl"), "ㄓㄢˋ")
+    XCTAssertEqual(c.cS2RC("jn"), "ㄓㄣ")
+    XCTAssertEqual(c.cS2RC("jnf"), "ㄓㄣˊ")
+    XCTAssertEqual(c.cS2RC("jnj"), "ㄓㄣˇ")
+    XCTAssertEqual(c.cS2RC("jnl"), "ㄓㄣˋ")
+    XCTAssertEqual(c.cS2RC("jg"), "ㄓㄤ")
+    XCTAssertEqual(c.cS2RC("jgj"), "ㄓㄤˇ")
+    XCTAssertEqual(c.cS2RC("jgl"), "ㄓㄤˋ")
+    XCTAssertEqual(c.cS2RC("jm"), "ㄓㄥ")
+    XCTAssertEqual(c.cS2RC("jmj"), "ㄓㄥˇ")
+    XCTAssertEqual(c.cS2RC("jml"), "ㄓㄥˋ")
+    XCTAssertEqual(c.cS2RC("ju"), "ㄓㄨ")
+    XCTAssertEqual(c.cS2RC("juf"), "ㄓㄨˊ")
+    XCTAssertEqual(c.cS2RC("juj"), "ㄓㄨˇ")
+    XCTAssertEqual(c.cS2RC("jul"), "ㄓㄨˋ")
+    XCTAssertEqual(c.cS2RC("jua"), "ㄓㄨㄚ")
+    XCTAssertEqual(c.cS2RC("juaj"), "ㄓㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("juo"), "ㄓㄨㄛ")
+    XCTAssertEqual(c.cS2RC("juof"), "ㄓㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("juol"), "ㄓㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("juh"), "ㄓㄨㄞ")
+  }
+}

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_C.swift

@@ -0,0 +1,521 @@
+// (c) 2022 and onwards The vChewing Project (MIT-NTL License).
+// ====================
+// This code is released under the MIT license (SPDX-License-Identifier: MIT)
+// ... with NTL restriction stating that:
+// No trademark license is granted to use the trade names, trademarks, service
+// marks, or product names of Contributor, except as required to fulfill notice
+// requirements defined in MIT License.
+
+import XCTest
+
+@testable import Tekkon
+
+extension TekkonTestsKeyboardArrangments {
+  func testAlvinLiuKeysC() throws {
+    var c = Tekkon.Composer(arrange: .ofAlvinLiu)
+    XCTAssertEqual(c.cS2RC("juhj"), "ㄓㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("juhl"), "ㄓㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("juk"), "ㄓㄨㄟ")
+    XCTAssertEqual(c.cS2RC("jukj"), "ㄓㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("jukl"), "ㄓㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("jub"), "ㄓㄨㄢ")
+    XCTAssertEqual(c.cS2RC("jubj"), "ㄓㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("jubl"), "ㄓㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("jun"), "ㄓㄨㄣ")
+    XCTAssertEqual(c.cS2RC("junj"), "ㄓㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("junl"), "ㄓㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("jug"), "ㄓㄨㄤ")
+    XCTAssertEqual(c.cS2RC("jugj"), "ㄓㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("jugl"), "ㄓㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("jum"), "ㄓㄨㄥ")
+    XCTAssertEqual(c.cS2RC("jumj"), "ㄓㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("juml"), "ㄓㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("q "), "ㄔ ")
+    XCTAssertEqual(c.cS2RC("qf"), "ㄔˊ")
+    XCTAssertEqual(c.cS2RC("qj"), "ㄔˇ")
+    XCTAssertEqual(c.cS2RC("ql"), "ㄔˋ")
+    XCTAssertEqual(c.cS2RC("qa"), "ㄔㄚ")
+    XCTAssertEqual(c.cS2RC("qaf"), "ㄔㄚˊ")
+    XCTAssertEqual(c.cS2RC("qaj"), "ㄔㄚˇ")
+    XCTAssertEqual(c.cS2RC("qal"), "ㄔㄚˋ")
+    XCTAssertEqual(c.cS2RC("qe"), "ㄔㄜ")
+    XCTAssertEqual(c.cS2RC("qej"), "ㄔㄜˇ")
+    XCTAssertEqual(c.cS2RC("qel"), "ㄔㄜˋ")
+    XCTAssertEqual(c.cS2RC("qh"), "ㄔㄞ")
+    XCTAssertEqual(c.cS2RC("qhf"), "ㄔㄞˊ")
+    XCTAssertEqual(c.cS2RC("qhj"), "ㄔㄞˇ")
+    XCTAssertEqual(c.cS2RC("qhl"), "ㄔㄞˋ")
+    XCTAssertEqual(c.cS2RC("qw"), "ㄔㄠ")
+    XCTAssertEqual(c.cS2RC("qwf"), "ㄔㄠˊ")
+    XCTAssertEqual(c.cS2RC("qwj"), "ㄔㄠˇ")
+    XCTAssertEqual(c.cS2RC("qwl"), "ㄔㄠˋ")
+    XCTAssertEqual(c.cS2RC("qv"), "ㄔㄡ")
+    XCTAssertEqual(c.cS2RC("qvf"), "ㄔㄡˊ")
+    XCTAssertEqual(c.cS2RC("qvj"), "ㄔㄡˇ")
+    XCTAssertEqual(c.cS2RC("qvl"), "ㄔㄡˋ")
+    XCTAssertEqual(c.cS2RC("qb"), "ㄔㄢ")
+    XCTAssertEqual(c.cS2RC("qbf"), "ㄔㄢˊ")
+    XCTAssertEqual(c.cS2RC("qbj"), "ㄔㄢˇ")
+    XCTAssertEqual(c.cS2RC("qbl"), "ㄔㄢˋ")
+    XCTAssertEqual(c.cS2RC("qn"), "ㄔㄣ")
+    XCTAssertEqual(c.cS2RC("qnf"), "ㄔㄣˊ")
+    XCTAssertEqual(c.cS2RC("qnj"), "ㄔㄣˇ")
+    XCTAssertEqual(c.cS2RC("qnl"), "ㄔㄣˋ")
+    XCTAssertEqual(c.cS2RC("qnd"), "ㄔㄣ˙")
+    XCTAssertEqual(c.cS2RC("qg"), "ㄔㄤ")
+    XCTAssertEqual(c.cS2RC("qgf"), "ㄔㄤˊ")
+    XCTAssertEqual(c.cS2RC("qgj"), "ㄔㄤˇ")
+    XCTAssertEqual(c.cS2RC("qgl"), "ㄔㄤˋ")
+    XCTAssertEqual(c.cS2RC("qm"), "ㄔㄥ")
+    XCTAssertEqual(c.cS2RC("qmf"), "ㄔㄥˊ")
+    XCTAssertEqual(c.cS2RC("qmj"), "ㄔㄥˇ")
+    XCTAssertEqual(c.cS2RC("qml"), "ㄔㄥˋ")
+    XCTAssertEqual(c.cS2RC("qu"), "ㄔㄨ")
+    XCTAssertEqual(c.cS2RC("quf"), "ㄔㄨˊ")
+    XCTAssertEqual(c.cS2RC("quj"), "ㄔㄨˇ")
+    XCTAssertEqual(c.cS2RC("qul"), "ㄔㄨˋ")
+    XCTAssertEqual(c.cS2RC("qua"), "ㄔㄨㄚ")
+    XCTAssertEqual(c.cS2RC("quaj"), "ㄔㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("qual"), "ㄔㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("quo"), "ㄔㄨㄛ")
+    XCTAssertEqual(c.cS2RC("quol"), "ㄔㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("quh"), "ㄔㄨㄞ")
+    XCTAssertEqual(c.cS2RC("quhf"), "ㄔㄨㄞˊ")
+    XCTAssertEqual(c.cS2RC("quhj"), "ㄔㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("quhl"), "ㄔㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("quk"), "ㄔㄨㄟ")
+    XCTAssertEqual(c.cS2RC("qukf"), "ㄔㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("qukj"), "ㄔㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("qukl"), "ㄔㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("qub"), "ㄔㄨㄢ")
+    XCTAssertEqual(c.cS2RC("qubf"), "ㄔㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("qubj"), "ㄔㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("qubl"), "ㄔㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("qun"), "ㄔㄨㄣ")
+    XCTAssertEqual(c.cS2RC("qunf"), "ㄔㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("qunj"), "ㄔㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("qug"), "ㄔㄨㄤ")
+    XCTAssertEqual(c.cS2RC("qugf"), "ㄔㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("qugj"), "ㄔㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("qugl"), "ㄔㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("qum"), "ㄔㄨㄥ")
+    XCTAssertEqual(c.cS2RC("qumf"), "ㄔㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("qumj"), "ㄔㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("quml"), "ㄔㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("x "), "ㄕ ")
+    XCTAssertEqual(c.cS2RC("xf"), "ㄕˊ")
+    XCTAssertEqual(c.cS2RC("xj"), "ㄕˇ")
+    XCTAssertEqual(c.cS2RC("xl"), "ㄕˋ")
+    XCTAssertEqual(c.cS2RC("xd"), "ㄕ˙")
+    XCTAssertEqual(c.cS2RC("xa"), "ㄕㄚ")
+    XCTAssertEqual(c.cS2RC("xaf"), "ㄕㄚˊ")
+    XCTAssertEqual(c.cS2RC("xaj"), "ㄕㄚˇ")
+    XCTAssertEqual(c.cS2RC("xal"), "ㄕㄚˋ")
+    XCTAssertEqual(c.cS2RC("xad"), "ㄕㄚ˙")
+    XCTAssertEqual(c.cS2RC("xe"), "ㄕㄜ")
+    XCTAssertEqual(c.cS2RC("xef"), "ㄕㄜˊ")
+    XCTAssertEqual(c.cS2RC("xej"), "ㄕㄜˇ")
+    XCTAssertEqual(c.cS2RC("xel"), "ㄕㄜˋ")
+    XCTAssertEqual(c.cS2RC("xh"), "ㄕㄞ")
+    XCTAssertEqual(c.cS2RC("xhj"), "ㄕㄞˇ")
+    XCTAssertEqual(c.cS2RC("xhl"), "ㄕㄞˋ")
+    XCTAssertEqual(c.cS2RC("xkf"), "ㄕㄟˊ")
+    XCTAssertEqual(c.cS2RC("xw"), "ㄕㄠ")
+    XCTAssertEqual(c.cS2RC("xwf"), "ㄕㄠˊ")
+    XCTAssertEqual(c.cS2RC("xwj"), "ㄕㄠˇ")
+    XCTAssertEqual(c.cS2RC("xwl"), "ㄕㄠˋ")
+    XCTAssertEqual(c.cS2RC("xv"), "ㄕㄡ")
+    XCTAssertEqual(c.cS2RC("xvf"), "ㄕㄡˊ")
+    XCTAssertEqual(c.cS2RC("xvj"), "ㄕㄡˇ")
+    XCTAssertEqual(c.cS2RC("xvl"), "ㄕㄡˋ")
+    XCTAssertEqual(c.cS2RC("xb"), "ㄕㄢ")
+    XCTAssertEqual(c.cS2RC("xbf"), "ㄕㄢˊ")
+    XCTAssertEqual(c.cS2RC("xbj"), "ㄕㄢˇ")
+    XCTAssertEqual(c.cS2RC("xbl"), "ㄕㄢˋ")
+    XCTAssertEqual(c.cS2RC("xn"), "ㄕㄣ")
+    XCTAssertEqual(c.cS2RC("xnf"), "ㄕㄣˊ")
+    XCTAssertEqual(c.cS2RC("xnj"), "ㄕㄣˇ")
+    XCTAssertEqual(c.cS2RC("xnl"), "ㄕㄣˋ")
+    XCTAssertEqual(c.cS2RC("xg"), "ㄕㄤ")
+    XCTAssertEqual(c.cS2RC("xgj"), "ㄕㄤˇ")
+    XCTAssertEqual(c.cS2RC("xgl"), "ㄕㄤˋ")
+    XCTAssertEqual(c.cS2RC("xgd"), "ㄕㄤ˙")
+    XCTAssertEqual(c.cS2RC("xm"), "ㄕㄥ")
+    XCTAssertEqual(c.cS2RC("xmf"), "ㄕㄥˊ")
+    XCTAssertEqual(c.cS2RC("xmj"), "ㄕㄥˇ")
+    XCTAssertEqual(c.cS2RC("xml"), "ㄕㄥˋ")
+    XCTAssertEqual(c.cS2RC("xu"), "ㄕㄨ")
+    XCTAssertEqual(c.cS2RC("xuf"), "ㄕㄨˊ")
+    XCTAssertEqual(c.cS2RC("xuj"), "ㄕㄨˇ")
+    XCTAssertEqual(c.cS2RC("xul"), "ㄕㄨˋ")
+    XCTAssertEqual(c.cS2RC("xua"), "ㄕㄨㄚ")
+    XCTAssertEqual(c.cS2RC("xuaj"), "ㄕㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("xual"), "ㄕㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("xuo"), "ㄕㄨㄛ")
+    XCTAssertEqual(c.cS2RC("xuol"), "ㄕㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("xuh"), "ㄕㄨㄞ")
+    XCTAssertEqual(c.cS2RC("xuhj"), "ㄕㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("xuhl"), "ㄕㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("xuk"), "ㄕㄨㄟ")
+    XCTAssertEqual(c.cS2RC("xukf"), "ㄕㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("xukj"), "ㄕㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("xukl"), "ㄕㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("xub"), "ㄕㄨㄢ")
+    XCTAssertEqual(c.cS2RC("xubl"), "ㄕㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("xunj"), "ㄕㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("xunl"), "ㄕㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("xug"), "ㄕㄨㄤ")
+    XCTAssertEqual(c.cS2RC("xugf"), "ㄕㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("xugj"), "ㄕㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("xugl"), "ㄕㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("rl"), "ㄖˋ")
+    XCTAssertEqual(c.cS2RC("rej"), "ㄖㄜˇ")
+    XCTAssertEqual(c.cS2RC("rel"), "ㄖㄜˋ")
+    XCTAssertEqual(c.cS2RC("rwf"), "ㄖㄠˊ")
+    XCTAssertEqual(c.cS2RC("rwj"), "ㄖㄠˇ")
+    XCTAssertEqual(c.cS2RC("rwl"), "ㄖㄠˋ")
+    XCTAssertEqual(c.cS2RC("rvf"), "ㄖㄡˊ")
+    XCTAssertEqual(c.cS2RC("rvj"), "ㄖㄡˇ")
+    XCTAssertEqual(c.cS2RC("rvl"), "ㄖㄡˋ")
+    XCTAssertEqual(c.cS2RC("rbf"), "ㄖㄢˊ")
+    XCTAssertEqual(c.cS2RC("rbj"), "ㄖㄢˇ")
+    XCTAssertEqual(c.cS2RC("rbl"), "ㄖㄢˋ")
+    XCTAssertEqual(c.cS2RC("rnf"), "ㄖㄣˊ")
+    XCTAssertEqual(c.cS2RC("rnj"), "ㄖㄣˇ")
+    XCTAssertEqual(c.cS2RC("rnl"), "ㄖㄣˋ")
+    XCTAssertEqual(c.cS2RC("rg"), "ㄖㄤ")
+    XCTAssertEqual(c.cS2RC("rgf"), "ㄖㄤˊ")
+    XCTAssertEqual(c.cS2RC("rgj"), "ㄖㄤˇ")
+    XCTAssertEqual(c.cS2RC("rgl"), "ㄖㄤˋ")
+    XCTAssertEqual(c.cS2RC("rm"), "ㄖㄥ")
+    XCTAssertEqual(c.cS2RC("rmf"), "ㄖㄥˊ")
+    XCTAssertEqual(c.cS2RC("rmj"), "ㄖㄥˇ")
+    XCTAssertEqual(c.cS2RC("rml"), "ㄖㄥˋ")
+    XCTAssertEqual(c.cS2RC("ruf"), "ㄖㄨˊ")
+    XCTAssertEqual(c.cS2RC("ruj"), "ㄖㄨˇ")
+    XCTAssertEqual(c.cS2RC("rul"), "ㄖㄨˋ")
+    XCTAssertEqual(c.cS2RC("ruof"), "ㄖㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("ruol"), "ㄖㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("rukf"), "ㄖㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("rukj"), "ㄖㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("rukl"), "ㄖㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("rubf"), "ㄖㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("rubj"), "ㄖㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("rubl"), "ㄖㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("runf"), "ㄖㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("runj"), "ㄖㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("runl"), "ㄖㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("rumf"), "ㄖㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("rumj"), "ㄖㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("ruml"), "ㄖㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("z"), "ㄗ")
+    XCTAssertEqual(c.cS2RC("zf"), "ㄗˊ")
+    XCTAssertEqual(c.cS2RC("zj"), "ㄗˇ")
+    XCTAssertEqual(c.cS2RC("zl"), "ㄗˋ")
+    XCTAssertEqual(c.cS2RC("zd"), "ㄗ˙")
+    XCTAssertEqual(c.cS2RC("za"), "ㄗㄚ")
+    XCTAssertEqual(c.cS2RC("zaf"), "ㄗㄚˊ")
+    XCTAssertEqual(c.cS2RC("zaj"), "ㄗㄚˇ")
+    XCTAssertEqual(c.cS2RC("zef"), "ㄗㄜˊ")
+    XCTAssertEqual(c.cS2RC("zej"), "ㄗㄜˇ")
+    XCTAssertEqual(c.cS2RC("zel"), "ㄗㄜˋ")
+    XCTAssertEqual(c.cS2RC("zh"), "ㄗㄞ")
+    XCTAssertEqual(c.cS2RC("zhj"), "ㄗㄞˇ")
+    XCTAssertEqual(c.cS2RC("zhl"), "ㄗㄞˋ")
+    XCTAssertEqual(c.cS2RC("zkf"), "ㄗㄟˊ")
+    XCTAssertEqual(c.cS2RC("zw"), "ㄗㄠ")
+    XCTAssertEqual(c.cS2RC("zwf"), "ㄗㄠˊ")
+    XCTAssertEqual(c.cS2RC("zwj"), "ㄗㄠˇ")
+    XCTAssertEqual(c.cS2RC("zwl"), "ㄗㄠˋ")
+    XCTAssertEqual(c.cS2RC("zv"), "ㄗㄡ")
+    XCTAssertEqual(c.cS2RC("zvj"), "ㄗㄡˇ")
+    XCTAssertEqual(c.cS2RC("zvl"), "ㄗㄡˋ")
+    XCTAssertEqual(c.cS2RC("zb"), "ㄗㄢ")
+    XCTAssertEqual(c.cS2RC("zbf"), "ㄗㄢˊ")
+    XCTAssertEqual(c.cS2RC("zbj"), "ㄗㄢˇ")
+    XCTAssertEqual(c.cS2RC("zbl"), "ㄗㄢˋ")
+    XCTAssertEqual(c.cS2RC("zn"), "ㄗㄣ")
+    XCTAssertEqual(c.cS2RC("znj"), "ㄗㄣˇ")
+    XCTAssertEqual(c.cS2RC("znl"), "ㄗㄣˋ")
+    XCTAssertEqual(c.cS2RC("zg"), "ㄗㄤ")
+    XCTAssertEqual(c.cS2RC("zgj"), "ㄗㄤˇ")
+    XCTAssertEqual(c.cS2RC("zgl"), "ㄗㄤˋ")
+    XCTAssertEqual(c.cS2RC("zm"), "ㄗㄥ")
+    XCTAssertEqual(c.cS2RC("zmj"), "ㄗㄥˇ")
+    XCTAssertEqual(c.cS2RC("zml"), "ㄗㄥˋ")
+    XCTAssertEqual(c.cS2RC("zu"), "ㄗㄨ")
+    XCTAssertEqual(c.cS2RC("zuf"), "ㄗㄨˊ")
+    XCTAssertEqual(c.cS2RC("zuj"), "ㄗㄨˇ")
+    XCTAssertEqual(c.cS2RC("zul"), "ㄗㄨˋ")
+    XCTAssertEqual(c.cS2RC("zuo"), "ㄗㄨㄛ")
+    XCTAssertEqual(c.cS2RC("zuof"), "ㄗㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("zuoj"), "ㄗㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("zuol"), "ㄗㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("zuod"), "ㄗㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("zuk"), "ㄗㄨㄟ")
+    XCTAssertEqual(c.cS2RC("zukj"), "ㄗㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("zukl"), "ㄗㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("zub"), "ㄗㄨㄢ")
+    XCTAssertEqual(c.cS2RC("zubj"), "ㄗㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("zubl"), "ㄗㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("zun"), "ㄗㄨㄣ")
+    XCTAssertEqual(c.cS2RC("zunj"), "ㄗㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("zunl"), "ㄗㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("zum"), "ㄗㄨㄥ")
+    XCTAssertEqual(c.cS2RC("zumj"), "ㄗㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("zuml"), "ㄗㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("c"), "ㄘ")
+    XCTAssertEqual(c.cS2RC("cf"), "ㄘˊ")
+    XCTAssertEqual(c.cS2RC("cj"), "ㄘˇ")
+    XCTAssertEqual(c.cS2RC("cl"), "ㄘˋ")
+    XCTAssertEqual(c.cS2RC("ca"), "ㄘㄚ")
+    XCTAssertEqual(c.cS2RC("caj"), "ㄘㄚˇ")
+    XCTAssertEqual(c.cS2RC("cal"), "ㄘㄚˋ")
+    XCTAssertEqual(c.cS2RC("cel"), "ㄘㄜˋ")
+    XCTAssertEqual(c.cS2RC("ch"), "ㄘㄞ")
+    XCTAssertEqual(c.cS2RC("chf"), "ㄘㄞˊ")
+    XCTAssertEqual(c.cS2RC("chj"), "ㄘㄞˇ")
+    XCTAssertEqual(c.cS2RC("chl"), "ㄘㄞˋ")
+    XCTAssertEqual(c.cS2RC("cw"), "ㄘㄠ")
+    XCTAssertEqual(c.cS2RC("cwf"), "ㄘㄠˊ")
+    XCTAssertEqual(c.cS2RC("cwj"), "ㄘㄠˇ")
+    XCTAssertEqual(c.cS2RC("cwl"), "ㄘㄠˋ")
+    XCTAssertEqual(c.cS2RC("cv"), "ㄘㄡ")
+    XCTAssertEqual(c.cS2RC("cvf"), "ㄘㄡˊ")
+    XCTAssertEqual(c.cS2RC("cvj"), "ㄘㄡˇ")
+    XCTAssertEqual(c.cS2RC("cvl"), "ㄘㄡˋ")
+    XCTAssertEqual(c.cS2RC("cb"), "ㄘㄢ")
+    XCTAssertEqual(c.cS2RC("cbf"), "ㄘㄢˊ")
+    XCTAssertEqual(c.cS2RC("cbj"), "ㄘㄢˇ")
+    XCTAssertEqual(c.cS2RC("cbl"), "ㄘㄢˋ")
+    XCTAssertEqual(c.cS2RC("cn"), "ㄘㄣ")
+    XCTAssertEqual(c.cS2RC("cnf"), "ㄘㄣˊ")
+    XCTAssertEqual(c.cS2RC("cg"), "ㄘㄤ")
+    XCTAssertEqual(c.cS2RC("cgf"), "ㄘㄤˊ")
+    XCTAssertEqual(c.cS2RC("cgj"), "ㄘㄤˇ")
+    XCTAssertEqual(c.cS2RC("cgl"), "ㄘㄤˋ")
+    XCTAssertEqual(c.cS2RC("cm"), "ㄘㄥ")
+    XCTAssertEqual(c.cS2RC("cmf"), "ㄘㄥˊ")
+    XCTAssertEqual(c.cS2RC("cmj"), "ㄘㄥˇ")
+    XCTAssertEqual(c.cS2RC("cml"), "ㄘㄥˋ")
+    XCTAssertEqual(c.cS2RC("cu"), "ㄘㄨ")
+    XCTAssertEqual(c.cS2RC("cuf"), "ㄘㄨˊ")
+    XCTAssertEqual(c.cS2RC("cuj"), "ㄘㄨˇ")
+    XCTAssertEqual(c.cS2RC("cul"), "ㄘㄨˋ")
+    XCTAssertEqual(c.cS2RC("cuo"), "ㄘㄨㄛ")
+    XCTAssertEqual(c.cS2RC("cuof"), "ㄘㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("cuoj"), "ㄘㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("cuol"), "ㄘㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("cuk"), "ㄘㄨㄟ")
+    XCTAssertEqual(c.cS2RC("cukj"), "ㄘㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("cukl"), "ㄘㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("cub"), "ㄘㄨㄢ")
+    XCTAssertEqual(c.cS2RC("cubf"), "ㄘㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("cubj"), "ㄘㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("cubl"), "ㄘㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("cun"), "ㄘㄨㄣ")
+    XCTAssertEqual(c.cS2RC("cunf"), "ㄘㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("cunj"), "ㄘㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("cunl"), "ㄘㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("cum"), "ㄘㄨㄥ")
+    XCTAssertEqual(c.cS2RC("cumf"), "ㄘㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("cumj"), "ㄘㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("cuml"), "ㄘㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("s"), "ㄙ")
+    XCTAssertEqual(c.cS2RC("sj"), "ㄙˇ")
+    XCTAssertEqual(c.cS2RC("sl"), "ㄙˋ")
+    XCTAssertEqual(c.cS2RC("sa"), "ㄙㄚ")
+    XCTAssertEqual(c.cS2RC("saj"), "ㄙㄚˇ")
+    XCTAssertEqual(c.cS2RC("sal"), "ㄙㄚˋ")
+    XCTAssertEqual(c.cS2RC("sad"), "ㄙㄚ˙")
+    XCTAssertEqual(c.cS2RC("se"), "ㄙㄜ")
+    XCTAssertEqual(c.cS2RC("sel"), "ㄙㄜˋ")
+    XCTAssertEqual(c.cS2RC("sh"), "ㄙㄞ")
+    XCTAssertEqual(c.cS2RC("shf"), "ㄙㄞˊ")
+    XCTAssertEqual(c.cS2RC("shj"), "ㄙㄞˇ")
+    XCTAssertEqual(c.cS2RC("shl"), "ㄙㄞˋ")
+    XCTAssertEqual(c.cS2RC("sk"), "ㄙㄟ")
+    XCTAssertEqual(c.cS2RC("sw"), "ㄙㄠ")
+    XCTAssertEqual(c.cS2RC("swj"), "ㄙㄠˇ")
+    XCTAssertEqual(c.cS2RC("swl"), "ㄙㄠˋ")
+    XCTAssertEqual(c.cS2RC("sv"), "ㄙㄡ")
+    XCTAssertEqual(c.cS2RC("svj"), "ㄙㄡˇ")
+    XCTAssertEqual(c.cS2RC("svl"), "ㄙㄡˋ")
+    XCTAssertEqual(c.cS2RC("sb"), "ㄙㄢ")
+    XCTAssertEqual(c.cS2RC("sbj"), "ㄙㄢˇ")
+    XCTAssertEqual(c.cS2RC("sbl"), "ㄙㄢˋ")
+    XCTAssertEqual(c.cS2RC("sn"), "ㄙㄣ")
+    XCTAssertEqual(c.cS2RC("snj"), "ㄙㄣˇ")
+    XCTAssertEqual(c.cS2RC("sg"), "ㄙㄤ")
+    XCTAssertEqual(c.cS2RC("sgj"), "ㄙㄤˇ")
+    XCTAssertEqual(c.cS2RC("sgl"), "ㄙㄤˋ")
+    XCTAssertEqual(c.cS2RC("sm"), "ㄙㄥ")
+    XCTAssertEqual(c.cS2RC("sml"), "ㄙㄥˋ")
+    XCTAssertEqual(c.cS2RC("su"), "ㄙㄨ")
+    XCTAssertEqual(c.cS2RC("suf"), "ㄙㄨˊ")
+    XCTAssertEqual(c.cS2RC("suj"), "ㄙㄨˇ")
+    XCTAssertEqual(c.cS2RC("sul"), "ㄙㄨˋ")
+    XCTAssertEqual(c.cS2RC("suo"), "ㄙㄨㄛ")
+    XCTAssertEqual(c.cS2RC("suof"), "ㄙㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("suoj"), "ㄙㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("suol"), "ㄙㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("suk"), "ㄙㄨㄟ")
+    XCTAssertEqual(c.cS2RC("sukf"), "ㄙㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("sukj"), "ㄙㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("sukl"), "ㄙㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("sub"), "ㄙㄨㄢ")
+    XCTAssertEqual(c.cS2RC("subj"), "ㄙㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("subl"), "ㄙㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("sun"), "ㄙㄨㄣ")
+    XCTAssertEqual(c.cS2RC("sunj"), "ㄙㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("sunl"), "ㄙㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("sum"), "ㄙㄨㄥ")
+    XCTAssertEqual(c.cS2RC("sumf"), "ㄙㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("sumj"), "ㄙㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("suml"), "ㄙㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("a"), "ㄚ")
+    XCTAssertEqual(c.cS2RC("af"), "ㄚˊ")
+    XCTAssertEqual(c.cS2RC("al"), "ㄚˋ")
+    XCTAssertEqual(c.cS2RC("ad"), "ㄚ˙")
+    XCTAssertEqual(c.cS2RC("o"), "ㄛ")
+    XCTAssertEqual(c.cS2RC("of"), "ㄛˊ")
+    XCTAssertEqual(c.cS2RC("oj"), "ㄛˇ")
+    XCTAssertEqual(c.cS2RC("ol"), "ㄛˋ")
+    XCTAssertEqual(c.cS2RC("e"), "ㄜ")
+    XCTAssertEqual(c.cS2RC("ef"), "ㄜˊ")
+    XCTAssertEqual(c.cS2RC("ej"), "ㄜˇ")
+    XCTAssertEqual(c.cS2RC("el"), "ㄜˋ")
+    // XCTAssertEqual(c.cS2RC("ef"), "ㄝˊ")
+    // XCTAssertEqual(c.cS2RC("ej"), "ㄝˇ")
+    // XCTAssertEqual(c.cS2RC("el"), "ㄝˋ")
+    // XCTAssertEqual(c.cS2RC("ed"), "ㄝ˙")
+    // XCTAssertEqual(c.cS2RC("h"), "ㄞ")
+    XCTAssertEqual(c.cS2RC("hf"), "ㄞˊ")
+    XCTAssertEqual(c.cS2RC("hj"), "ㄞˇ")
+    XCTAssertEqual(c.cS2RC("hl"), "ㄞˋ")
+    XCTAssertEqual(c.cS2RC("kl"), "ㄟˋ")
+    XCTAssertEqual(c.cS2RC("w"), "ㄠ")
+    XCTAssertEqual(c.cS2RC("wf"), "ㄠˊ")
+    XCTAssertEqual(c.cS2RC("wj"), "ㄠˇ")
+    XCTAssertEqual(c.cS2RC("wl"), "ㄠˋ")
+    XCTAssertEqual(c.cS2RC("v"), "ㄡ")
+    XCTAssertEqual(c.cS2RC("vf"), "ㄡˊ")
+    XCTAssertEqual(c.cS2RC("vj"), "ㄡˇ")
+    XCTAssertEqual(c.cS2RC("vl"), "ㄡˋ")
+    XCTAssertEqual(c.cS2RC("vd"), "ㄡ˙")
+    XCTAssertEqual(c.cS2RC("b "), "ㄢ ")
+    XCTAssertEqual(c.cS2RC("bf"), "ㄢˊ")
+    XCTAssertEqual(c.cS2RC("bj"), "ㄢˇ")
+    XCTAssertEqual(c.cS2RC("bl"), "ㄢˋ")
+    XCTAssertEqual(c.cS2RC("n "), "ㄣ ")
+    XCTAssertEqual(c.cS2RC("nf"), "ㄣˊ")
+    XCTAssertEqual(c.cS2RC("nj"), "ㄣˇ")
+    XCTAssertEqual(c.cS2RC("nl"), "ㄣˋ")
+    XCTAssertEqual(c.cS2RC("nd"), "ㄣ˙")
+    XCTAssertEqual(c.cS2RC("g "), "ㄤ ")
+    XCTAssertEqual(c.cS2RC("gf"), "ㄤˊ")
+    XCTAssertEqual(c.cS2RC("gj"), "ㄤˇ")
+    XCTAssertEqual(c.cS2RC("gl"), "ㄤˋ")
+    XCTAssertEqual(c.cS2RC("m "), "ㄥ ")
+    XCTAssertEqual(c.cS2RC("ml"), "ㄥˋ")
+    XCTAssertEqual(c.cS2RC("l "), "ㄦ ")
+    XCTAssertEqual(c.cS2RC("lf"), "ㄦˊ")
+    XCTAssertEqual(c.cS2RC("lj"), "ㄦˇ")
+    XCTAssertEqual(c.cS2RC("ll"), "ㄦˋ")
+    XCTAssertEqual(c.cS2RC("ld"), "ㄦ˙")
+    XCTAssertEqual(c.cS2RC("i"), "ㄧ")
+    XCTAssertEqual(c.cS2RC("if"), "ㄧˊ")
+    XCTAssertEqual(c.cS2RC("ij"), "ㄧˇ")
+    XCTAssertEqual(c.cS2RC("il"), "ㄧˋ")
+    XCTAssertEqual(c.cS2RC("ia"), "ㄧㄚ")
+    XCTAssertEqual(c.cS2RC("iaf"), "ㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("iaj"), "ㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("ial"), "ㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("iad"), "ㄧㄚ˙")
+    XCTAssertEqual(c.cS2RC("io"), "ㄧㄛ")
+    XCTAssertEqual(c.cS2RC("iod"), "ㄧㄛ˙")
+    XCTAssertEqual(c.cS2RC("ie"), "ㄧㄝ")
+    XCTAssertEqual(c.cS2RC("ief"), "ㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("iej"), "ㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("iel"), "ㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("ied"), "ㄧㄝ˙")
+    XCTAssertEqual(c.cS2RC("ihf"), "ㄧㄞˊ")
+    XCTAssertEqual(c.cS2RC("iw"), "ㄧㄠ")
+    XCTAssertEqual(c.cS2RC("iwf"), "ㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("iwj"), "ㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("iwl"), "ㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("iv"), "ㄧㄡ")
+    XCTAssertEqual(c.cS2RC("ivf"), "ㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("ivj"), "ㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("ivl"), "ㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("ib"), "ㄧㄢ")
+    XCTAssertEqual(c.cS2RC("ibf"), "ㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("ibj"), "ㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("ibl"), "ㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("in"), "ㄧㄣ")
+    XCTAssertEqual(c.cS2RC("inf"), "ㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("inj"), "ㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("inl"), "ㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("ig"), "ㄧㄤ")
+    XCTAssertEqual(c.cS2RC("igf"), "ㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("igj"), "ㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("igl"), "ㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("im"), "ㄧㄥ")
+    XCTAssertEqual(c.cS2RC("imf"), "ㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("imj"), "ㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("iml"), "ㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("u"), "ㄨ")
+    XCTAssertEqual(c.cS2RC("uf"), "ㄨˊ")
+    XCTAssertEqual(c.cS2RC("uj"), "ㄨˇ")
+    XCTAssertEqual(c.cS2RC("ul"), "ㄨˋ")
+    XCTAssertEqual(c.cS2RC("ua"), "ㄨㄚ")
+    XCTAssertEqual(c.cS2RC("uaf"), "ㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("uaj"), "ㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("ual"), "ㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("uad"), "ㄨㄚ˙")
+    XCTAssertEqual(c.cS2RC("uo"), "ㄨㄛ")
+    XCTAssertEqual(c.cS2RC("uoj"), "ㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("uol"), "ㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("uh"), "ㄨㄞ")
+    XCTAssertEqual(c.cS2RC("uhj"), "ㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("uhl"), "ㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("uk"), "ㄨㄟ")
+    XCTAssertEqual(c.cS2RC("ukf"), "ㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("ukj"), "ㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("ukl"), "ㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("ub"), "ㄨㄢ")
+    XCTAssertEqual(c.cS2RC("ubf"), "ㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("ubj"), "ㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("ubl"), "ㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("un"), "ㄨㄣ")
+    XCTAssertEqual(c.cS2RC("unf"), "ㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("unj"), "ㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("unl"), "ㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("ug"), "ㄨㄤ")
+    XCTAssertEqual(c.cS2RC("ugf"), "ㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("ugj"), "ㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("ugl"), "ㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("um"), "ㄨㄥ")
+    XCTAssertEqual(c.cS2RC("umj"), "ㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("uml"), "ㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("y"), "ㄩ")
+    XCTAssertEqual(c.cS2RC("yf"), "ㄩˊ")
+    XCTAssertEqual(c.cS2RC("yj"), "ㄩˇ")
+    XCTAssertEqual(c.cS2RC("yl"), "ㄩˋ")
+    XCTAssertEqual(c.cS2RC("ye"), "ㄩㄝ")
+    XCTAssertEqual(c.cS2RC("yej"), "ㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("yel"), "ㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("yb"), "ㄩㄢ")
+    XCTAssertEqual(c.cS2RC("ybf"), "ㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("ybj"), "ㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("ybl"), "ㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("yn"), "ㄩㄣ")
+    XCTAssertEqual(c.cS2RC("ynf"), "ㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("ynj"), "ㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("ynl"), "ㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("ym"), "ㄩㄥ")
+    XCTAssertEqual(c.cS2RC("ymf"), "ㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("ymj"), "ㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("yml"), "ㄩㄥˋ")
+  }
+}

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_AlvinLiu_D.swift

@@ -0,0 +1,88 @@
+// (c) 2022 and onwards The vChewing Project (MIT-NTL License).
+// ====================
+// This code is released under the MIT license (SPDX-License-Identifier: MIT)
+// ... with NTL restriction stating that:
+// No trademark license is granted to use the trade names, trademarks, service
+// marks, or product names of Contributor, except as required to fulfill notice
+// requirements defined in MIT License.
+
+import XCTest
+
+@testable import Tekkon
+
+extension TekkonTestsKeyboardArrangments {
+  func testAlvinLiuKeysMicrosoftCompatible() throws {
+    var c = Tekkon.Composer(arrange: .ofAlvinLiu)
+    XCTAssertEqual(c.cS2RC("bic"), "ㄅㄧㄝ")
+    XCTAssertEqual(c.cS2RC("bicf"), "ㄅㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("bicj"), "ㄅㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("bicl"), "ㄅㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("pic"), "ㄆㄧㄝ")
+    XCTAssertEqual(c.cS2RC("picj"), "ㄆㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("picl"), "ㄆㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("mic"), "ㄇㄧㄝ")
+    XCTAssertEqual(c.cS2RC("micf"), "ㄇㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("micl"), "ㄇㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("dic"), "ㄉㄧㄝ")
+    XCTAssertEqual(c.cS2RC("dicf"), "ㄉㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("dicj"), "ㄉㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("dicl"), "ㄉㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("tic"), "ㄊㄧㄝ")
+    XCTAssertEqual(c.cS2RC("ticf"), "ㄊㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("ticj"), "ㄊㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("ticl"), "ㄊㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("nic"), "ㄋㄧㄝ")
+    XCTAssertEqual(c.cS2RC("nicf"), "ㄋㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("nicl"), "ㄋㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("nycl"), "ㄋㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("lic"), "ㄌㄧㄝ")
+    XCTAssertEqual(c.cS2RC("licf"), "ㄌㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("licj"), "ㄌㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("licl"), "ㄌㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("lyc"), "ㄌㄩㄝ")
+    XCTAssertEqual(c.cS2RC("lycj"), "ㄌㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("lycl"), "ㄌㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("jic"), "ㄐㄧㄝ")
+    XCTAssertEqual(c.cS2RC("jicf"), "ㄐㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("jicj"), "ㄐㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("jicl"), "ㄐㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("jicd"), "ㄐㄧㄝ˙")
+    XCTAssertEqual(c.cS2RC("jyc"), "ㄐㄩㄝ")
+    XCTAssertEqual(c.cS2RC("jycf"), "ㄐㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("jycj"), "ㄐㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("jycl"), "ㄐㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("qic"), "ㄑㄧㄝ")
+    XCTAssertEqual(c.cS2RC("qicf"), "ㄑㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("qicj"), "ㄑㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("qicl"), "ㄑㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("qyc"), "ㄑㄩㄝ")
+    XCTAssertEqual(c.cS2RC("qycf"), "ㄑㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("qycl"), "ㄑㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("xic"), "ㄒㄧㄝ")
+    XCTAssertEqual(c.cS2RC("xicf"), "ㄒㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("xicj"), "ㄒㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("xicl"), "ㄒㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("xyc"), "ㄒㄩㄝ")
+    XCTAssertEqual(c.cS2RC("xycf"), "ㄒㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("xycj"), "ㄒㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("xycl"), "ㄒㄩㄝˋ")
+    // XCTAssertEqual(c.cS2RC("cf"), "ㄝˊ")
+    // XCTAssertEqual(c.cS2RC("cj"), "ㄝˇ")
+    // XCTAssertEqual(c.cS2RC("cl"), "ㄝˋ")
+    // XCTAssertEqual(c.cS2RC("cd"), "ㄝ˙")
+    XCTAssertEqual(c.cS2RC("h "), "ㄞ ")
+    XCTAssertEqual(c.cS2RC("t "), "ㄦ ")
+    XCTAssertEqual(c.cS2RC("tf"), "ㄦˊ")
+    XCTAssertEqual(c.cS2RC("tj"), "ㄦˇ")
+    XCTAssertEqual(c.cS2RC("tl"), "ㄦˋ")
+    XCTAssertEqual(c.cS2RC("td"), "ㄦ˙")
+    XCTAssertEqual(c.cS2RC("ic"), "ㄧㄝ")
+    XCTAssertEqual(c.cS2RC("icf"), "ㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("icj"), "ㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("icl"), "ㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("icd"), "ㄧㄝ˙")
+    XCTAssertEqual(c.cS2RC("yc"), "ㄩㄝ")
+    XCTAssertEqual(c.cS2RC("ycj"), "ㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("ycl"), "ㄩㄝˋ")
+  }
+}

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Basic_DachenTrad.swift

@@ -13,20 +13,28 @@ import XCTest
 final class TekkonTestsKeyboardArrangments: XCTestCase {
   func testQwertyDachenKeys() throws {
     // Testing Dachen Traditional Mapping (QWERTY)
-    var composer = Tekkon.Composer(arrange: .ofDachen)
+    var c = Tekkon.Composer(arrange: .ofDachen)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("18 "), "ㄅㄚ ")
+    XCTAssertEqual(c.cS2RC("18 "), "ㄅㄚ ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("m,4"), "ㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("m,4"), "ㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("5j/ "), "ㄓㄨㄥ ")
+    XCTAssertEqual(c.cS2RC("5j/ "), "ㄓㄨㄥ ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fu."), "ㄑㄧㄡ")
+    XCTAssertEqual(c.cS2RC("fu."), "ㄑㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("g0 "), "ㄕㄢ ")
+    XCTAssertEqual(c.cS2RC("g0 "), "ㄕㄢ ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xup6"), "ㄌㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("xup6"), "ㄌㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xu;6"), "ㄌㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("xu;6"), "ㄌㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("z/"), "ㄈㄥ")
+    XCTAssertEqual(c.cS2RC("z/"), "ㄈㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tjo "), "ㄔㄨㄟ ")
+    XCTAssertEqual(c.cS2RC("tjo "), "ㄔㄨㄟ ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("284"), "ㄉㄚˋ")
+    XCTAssertEqual(c.cS2RC("284"), "ㄉㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("2u4"), "ㄉㄧˋ")
+    XCTAssertEqual(c.cS2RC("2u4"), "ㄉㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hl3"), "ㄘㄠˇ")
+    XCTAssertEqual(c.cS2RC("hl3"), "ㄘㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("5 "), "ㄓ ")
+    XCTAssertEqual(c.cS2RC("5 "), "ㄓ ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("193"), "ㄅㄞˇ")
+    XCTAssertEqual(c.cS2RC("193"), "ㄅㄞˇ")
+  }
+}
+
+internal extension Tekkon.Composer {
+  // Exactly "convertSequenceToRawComposition()" but with shorter symbol name.
+  mutating func cS2RC(_ givenSequence: String = "") -> String {
+    receiveSequence(givenSequence)
+    return value
   }
 }

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_A.swift

@@ -11,492 +11,496 @@ import XCTest
 @testable import Tekkon
 
 extension TekkonTestsKeyboardArrangments {
+  func testDachen26KeysTaigi() throws {
+    var c = Tekkon.Composer(arrange: .ofDachen26)
+    XCTAssertEqual(c.cS2RC("dull"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("eule"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("eup"), "ㄍㄧㄣ")
+  }
+
   func testDachen26KeysA() throws {
-    var composer = Tekkon.Composer(arrange: .ofDachen26)
+    var c = Tekkon.Composer(arrange: .ofDachen26)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dull"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("qqulle"), "ㄅㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eule"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("qqulld"), "ㄅㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eup"), "ㄍㄧㄣ")
+    XCTAssertEqual(c.cS2RC("wwjll"), "ㄉㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqulle"), "ㄅㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("qquu"), "ㄅㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqulld"), "ㄅㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("qquue"), "ㄅㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjll"), "ㄉㄨㄤ")
+    XCTAssertEqual(c.cS2RC("qquur"), "ㄅㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquu"), "ㄅㄚ")
+    XCTAssertEqual(c.cS2RC("qquud"), "ㄅㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquue"), "ㄅㄚˊ")
+    XCTAssertEqual(c.cS2RC("qquuy"), "ㄅㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquur"), "ㄅㄚˇ")
+    XCTAssertEqual(c.cS2RC("qqi"), "ㄅㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquud"), "ㄅㄚˋ")
+    XCTAssertEqual(c.cS2RC("qqie"), "ㄅㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquuy"), "ㄅㄚ˙")
+    XCTAssertEqual(c.cS2RC("qqir"), "ㄅㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqi"), "ㄅㄛ")
+    XCTAssertEqual(c.cS2RC("qqid"), "ㄅㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqie"), "ㄅㄛˊ")
+    XCTAssertEqual(c.cS2RC("qqiy"), "ㄅㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqir"), "ㄅㄛˇ")
+    XCTAssertEqual(c.cS2RC("qqii"), "ㄅㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqid"), "ㄅㄛˋ")
+    XCTAssertEqual(c.cS2RC("qqiie"), "ㄅㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqiy"), "ㄅㄛ˙")
+    XCTAssertEqual(c.cS2RC("qqiir"), "ㄅㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqii"), "ㄅㄞ")
+    XCTAssertEqual(c.cS2RC("qqiid"), "ㄅㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqiie"), "ㄅㄞˊ")
+    XCTAssertEqual(c.cS2RC("qqiiy"), "ㄅㄞ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqiir"), "ㄅㄞˇ")
+    XCTAssertEqual(c.cS2RC("qqo"), "ㄅㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqiid"), "ㄅㄞˋ")
+    XCTAssertEqual(c.cS2RC("qqor"), "ㄅㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqiiy"), "ㄅㄞ˙")
+    XCTAssertEqual(c.cS2RC("qqod"), "ㄅㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqo"), "ㄅㄟ")
+    XCTAssertEqual(c.cS2RC("qqoy"), "ㄅㄟ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqor"), "ㄅㄟˇ")
+    XCTAssertEqual(c.cS2RC("qql"), "ㄅㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqod"), "ㄅㄟˋ")
+    XCTAssertEqual(c.cS2RC("qqle"), "ㄅㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqoy"), "ㄅㄟ˙")
+    XCTAssertEqual(c.cS2RC("qqlr"), "ㄅㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qql"), "ㄅㄠ")
+    XCTAssertEqual(c.cS2RC("qqld"), "ㄅㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqle"), "ㄅㄠˊ")
+    XCTAssertEqual(c.cS2RC("qqoo"), "ㄅㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqlr"), "ㄅㄠˇ")
+    XCTAssertEqual(c.cS2RC("qqoor"), "ㄅㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqld"), "ㄅㄠˋ")
+    XCTAssertEqual(c.cS2RC("qqood"), "ㄅㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqoo"), "ㄅㄢ")
+    XCTAssertEqual(c.cS2RC("qqp"), "ㄅㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqoor"), "ㄅㄢˇ")
+    XCTAssertEqual(c.cS2RC("qqpr"), "ㄅㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqood"), "ㄅㄢˋ")
+    XCTAssertEqual(c.cS2RC("qqpd"), "ㄅㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqp"), "ㄅㄣ")
+    XCTAssertEqual(c.cS2RC("qqll"), "ㄅㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqpr"), "ㄅㄣˇ")
+    XCTAssertEqual(c.cS2RC("qqllr"), "ㄅㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqpd"), "ㄅㄣˋ")
+    XCTAssertEqual(c.cS2RC("qqlld"), "ㄅㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqll"), "ㄅㄤ")
+    XCTAssertEqual(c.cS2RC("qqn"), "ㄅㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqllr"), "ㄅㄤˇ")
+    XCTAssertEqual(c.cS2RC("qqne"), "ㄅㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqlld"), "ㄅㄤˋ")
+    XCTAssertEqual(c.cS2RC("qqnr"), "ㄅㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqn"), "ㄅㄥ")
+    XCTAssertEqual(c.cS2RC("qqnd"), "ㄅㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqne"), "ㄅㄥˊ")
+    XCTAssertEqual(c.cS2RC("qqu"), "ㄅㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqnr"), "ㄅㄥˇ")
+    XCTAssertEqual(c.cS2RC("qque"), "ㄅㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqnd"), "ㄅㄥˋ")
+    XCTAssertEqual(c.cS2RC("qqur"), "ㄅㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqu"), "ㄅㄧ")
+    XCTAssertEqual(c.cS2RC("qqud"), "ㄅㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qque"), "ㄅㄧˊ")
+    XCTAssertEqual(c.cS2RC("qqub"), "ㄅㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqur"), "ㄅㄧˇ")
+    XCTAssertEqual(c.cS2RC("qqube"), "ㄅㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqud"), "ㄅㄧˋ")
+    XCTAssertEqual(c.cS2RC("qqubr"), "ㄅㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqub"), "ㄅㄧㄝ")
+    XCTAssertEqual(c.cS2RC("qqubd"), "ㄅㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqube"), "ㄅㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("qqul"), "ㄅㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqubr"), "ㄅㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("qqulr"), "ㄅㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqubd"), "ㄅㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("qquld"), "ㄅㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqul"), "ㄅㄧㄠ")
+    XCTAssertEqual(c.cS2RC("qquoo"), "ㄅㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqulr"), "ㄅㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("qquooe"), "ㄅㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquld"), "ㄅㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("qquoor"), "ㄅㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquoo"), "ㄅㄧㄢ")
+    XCTAssertEqual(c.cS2RC("qquood"), "ㄅㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquooe"), "ㄅㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("qqup"), "ㄅㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquoor"), "ㄅㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("qqupr"), "ㄅㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qquood"), "ㄅㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("qqupd"), "ㄅㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqup"), "ㄅㄧㄣ")
+    XCTAssertEqual(c.cS2RC("qqun"), "ㄅㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqupr"), "ㄅㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("qqunr"), "ㄅㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqupd"), "ㄅㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("qqund"), "ㄅㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqun"), "ㄅㄧㄥ")
+    XCTAssertEqual(c.cS2RC("qqj"), "ㄅㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqunr"), "ㄅㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("qqje"), "ㄅㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqund"), "ㄅㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("qqjr"), "ㄅㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqj"), "ㄅㄨ")
+    XCTAssertEqual(c.cS2RC("qqjd"), "ㄅㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqje"), "ㄅㄨˊ")
+    XCTAssertEqual(c.cS2RC("quu"), "ㄆㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqjr"), "ㄅㄨˇ")
+    XCTAssertEqual(c.cS2RC("quue"), "ㄆㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qqjd"), "ㄅㄨˋ")
+    XCTAssertEqual(c.cS2RC("quur"), "ㄆㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quu"), "ㄆㄚ")
+    XCTAssertEqual(c.cS2RC("quud"), "ㄆㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quue"), "ㄆㄚˊ")
+    XCTAssertEqual(c.cS2RC("quuy"), "ㄆㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quur"), "ㄆㄚˇ")
+    XCTAssertEqual(c.cS2RC("qi"), "ㄆㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quud"), "ㄆㄚˋ")
+    XCTAssertEqual(c.cS2RC("qie"), "ㄆㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quuy"), "ㄆㄚ˙")
+    XCTAssertEqual(c.cS2RC("qir"), "ㄆㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qi"), "ㄆㄛ")
+    XCTAssertEqual(c.cS2RC("qid"), "ㄆㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qie"), "ㄆㄛˊ")
+    XCTAssertEqual(c.cS2RC("qii"), "ㄆㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qir"), "ㄆㄛˇ")
+    XCTAssertEqual(c.cS2RC("qiie"), "ㄆㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qid"), "ㄆㄛˋ")
+    XCTAssertEqual(c.cS2RC("qiir"), "ㄆㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qii"), "ㄆㄞ")
+    XCTAssertEqual(c.cS2RC("qiid"), "ㄆㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qiie"), "ㄆㄞˊ")
+    XCTAssertEqual(c.cS2RC("qo"), "ㄆㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qiir"), "ㄆㄞˇ")
+    XCTAssertEqual(c.cS2RC("qoe"), "ㄆㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qiid"), "ㄆㄞˋ")
+    XCTAssertEqual(c.cS2RC("qor"), "ㄆㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qo"), "ㄆㄟ")
+    XCTAssertEqual(c.cS2RC("qod"), "ㄆㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qoe"), "ㄆㄟˊ")
+    XCTAssertEqual(c.cS2RC("ql"), "ㄆㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qor"), "ㄆㄟˇ")
+    XCTAssertEqual(c.cS2RC("qle"), "ㄆㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qod"), "ㄆㄟˋ")
+    XCTAssertEqual(c.cS2RC("qlr"), "ㄆㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ql"), "ㄆㄠ")
+    XCTAssertEqual(c.cS2RC("qld"), "ㄆㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qle"), "ㄆㄠˊ")
+    XCTAssertEqual(c.cS2RC("qm"), "ㄆㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qlr"), "ㄆㄠˇ")
+    XCTAssertEqual(c.cS2RC("qme"), "ㄆㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qld"), "ㄆㄠˋ")
+    XCTAssertEqual(c.cS2RC("qmr"), "ㄆㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qm"), "ㄆㄡ")
+    XCTAssertEqual(c.cS2RC("qmd"), "ㄆㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qme"), "ㄆㄡˊ")
+    XCTAssertEqual(c.cS2RC("qoo"), "ㄆㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qmr"), "ㄆㄡˇ")
+    XCTAssertEqual(c.cS2RC("qooe"), "ㄆㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qmd"), "ㄆㄡˋ")
+    XCTAssertEqual(c.cS2RC("qoor"), "ㄆㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qoo"), "ㄆㄢ")
+    XCTAssertEqual(c.cS2RC("qood"), "ㄆㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qooe"), "ㄆㄢˊ")
+    XCTAssertEqual(c.cS2RC("qp"), "ㄆㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qoor"), "ㄆㄢˇ")
+    XCTAssertEqual(c.cS2RC("qpe"), "ㄆㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qood"), "ㄆㄢˋ")
+    XCTAssertEqual(c.cS2RC("qpr"), "ㄆㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qp"), "ㄆㄣ")
+    XCTAssertEqual(c.cS2RC("qpd"), "ㄆㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qpe"), "ㄆㄣˊ")
+    XCTAssertEqual(c.cS2RC("qll"), "ㄆㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qpr"), "ㄆㄣˇ")
+    XCTAssertEqual(c.cS2RC("qlle"), "ㄆㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qpd"), "ㄆㄣˋ")
+    XCTAssertEqual(c.cS2RC("qllr"), "ㄆㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qll"), "ㄆㄤ")
+    XCTAssertEqual(c.cS2RC("qlld"), "ㄆㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qlle"), "ㄆㄤˊ")
+    XCTAssertEqual(c.cS2RC("qn"), "ㄆㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qllr"), "ㄆㄤˇ")
+    XCTAssertEqual(c.cS2RC("qne"), "ㄆㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qlld"), "ㄆㄤˋ")
+    XCTAssertEqual(c.cS2RC("qnr"), "ㄆㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qn"), "ㄆㄥ")
+    XCTAssertEqual(c.cS2RC("qnd"), "ㄆㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qne"), "ㄆㄥˊ")
+    XCTAssertEqual(c.cS2RC("qu"), "ㄆㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qnr"), "ㄆㄥˇ")
+    XCTAssertEqual(c.cS2RC("que"), "ㄆㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qnd"), "ㄆㄥˋ")
+    XCTAssertEqual(c.cS2RC("qur"), "ㄆㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qu"), "ㄆㄧ")
+    XCTAssertEqual(c.cS2RC("qud"), "ㄆㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("que"), "ㄆㄧˊ")
+    XCTAssertEqual(c.cS2RC("quuu"), "ㄆㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qur"), "ㄆㄧˇ")
+    XCTAssertEqual(c.cS2RC("qub"), "ㄆㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qud"), "ㄆㄧˋ")
+    XCTAssertEqual(c.cS2RC("qubr"), "ㄆㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quuu"), "ㄆㄧㄚ")
+    XCTAssertEqual(c.cS2RC("qubd"), "ㄆㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qub"), "ㄆㄧㄝ")
+    XCTAssertEqual(c.cS2RC("qul"), "ㄆㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qubr"), "ㄆㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("qule"), "ㄆㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qubd"), "ㄆㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("qulr"), "ㄆㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qul"), "ㄆㄧㄠ")
+    XCTAssertEqual(c.cS2RC("quld"), "ㄆㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qule"), "ㄆㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("quoo"), "ㄆㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qulr"), "ㄆㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("quooe"), "ㄆㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quld"), "ㄆㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("quoor"), "ㄆㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quoo"), "ㄆㄧㄢ")
+    XCTAssertEqual(c.cS2RC("quood"), "ㄆㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quooe"), "ㄆㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("qup"), "ㄆㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quoor"), "ㄆㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("qupe"), "ㄆㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("quood"), "ㄆㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("qupr"), "ㄆㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qup"), "ㄆㄧㄣ")
+    XCTAssertEqual(c.cS2RC("qupd"), "ㄆㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qupe"), "ㄆㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("qun"), "ㄆㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qupr"), "ㄆㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("qune"), "ㄆㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qupd"), "ㄆㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("qunr"), "ㄆㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qun"), "ㄆㄧㄥ")
+    XCTAssertEqual(c.cS2RC("qund"), "ㄆㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qune"), "ㄆㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("qj"), "ㄆㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qunr"), "ㄆㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("qje"), "ㄆㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qund"), "ㄆㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("qjr"), "ㄆㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qj"), "ㄆㄨ")
+    XCTAssertEqual(c.cS2RC("qjd"), "ㄆㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qje"), "ㄆㄨˊ")
+    XCTAssertEqual(c.cS2RC("auu"), "ㄇㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qjr"), "ㄆㄨˇ")
+    XCTAssertEqual(c.cS2RC("auue"), "ㄇㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qjd"), "ㄆㄨˋ")
+    XCTAssertEqual(c.cS2RC("auur"), "ㄇㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auu"), "ㄇㄚ")
+    XCTAssertEqual(c.cS2RC("auud"), "ㄇㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auue"), "ㄇㄚˊ")
+    XCTAssertEqual(c.cS2RC("auuy"), "ㄇㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auur"), "ㄇㄚˇ")
+    XCTAssertEqual(c.cS2RC("ai"), "ㄇㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auud"), "ㄇㄚˋ")
+    XCTAssertEqual(c.cS2RC("aie"), "ㄇㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auuy"), "ㄇㄚ˙")
+    XCTAssertEqual(c.cS2RC("air"), "ㄇㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ai"), "ㄇㄛ")
+    XCTAssertEqual(c.cS2RC("aid"), "ㄇㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aie"), "ㄇㄛˊ")
+    XCTAssertEqual(c.cS2RC("aiy"), "ㄇㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("air"), "ㄇㄛˇ")
+    XCTAssertEqual(c.cS2RC("ak"), "ㄇㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aid"), "ㄇㄛˋ")
+    XCTAssertEqual(c.cS2RC("akd"), "ㄇㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aiy"), "ㄇㄛ˙")
+    XCTAssertEqual(c.cS2RC("aky"), "ㄇㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ak"), "ㄇㄜ")
+    XCTAssertEqual(c.cS2RC("aii"), "ㄇㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("akd"), "ㄇㄜˋ")
+    XCTAssertEqual(c.cS2RC("aiie"), "ㄇㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aky"), "ㄇㄜ˙")
+    XCTAssertEqual(c.cS2RC("aiir"), "ㄇㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aii"), "ㄇㄞ")
+    XCTAssertEqual(c.cS2RC("aiid"), "ㄇㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aiie"), "ㄇㄞˊ")
+    XCTAssertEqual(c.cS2RC("aoe"), "ㄇㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aiir"), "ㄇㄞˇ")
+    XCTAssertEqual(c.cS2RC("aor"), "ㄇㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aiid"), "ㄇㄞˋ")
+    XCTAssertEqual(c.cS2RC("aod"), "ㄇㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aoe"), "ㄇㄟˊ")
+    XCTAssertEqual(c.cS2RC("al"), "ㄇㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aor"), "ㄇㄟˇ")
+    XCTAssertEqual(c.cS2RC("ale"), "ㄇㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aod"), "ㄇㄟˋ")
+    XCTAssertEqual(c.cS2RC("alr"), "ㄇㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("al"), "ㄇㄠ")
+    XCTAssertEqual(c.cS2RC("ald"), "ㄇㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ale"), "ㄇㄠˊ")
+    XCTAssertEqual(c.cS2RC("ame"), "ㄇㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("alr"), "ㄇㄠˇ")
+    XCTAssertEqual(c.cS2RC("amr"), "ㄇㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ald"), "ㄇㄠˋ")
+    XCTAssertEqual(c.cS2RC("amd"), "ㄇㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ame"), "ㄇㄡˊ")
+    XCTAssertEqual(c.cS2RC("aoo"), "ㄇㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("amr"), "ㄇㄡˇ")
+    XCTAssertEqual(c.cS2RC("aooe"), "ㄇㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("amd"), "ㄇㄡˋ")
+    XCTAssertEqual(c.cS2RC("aoor"), "ㄇㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aoo"), "ㄇㄢ")
+    XCTAssertEqual(c.cS2RC("aood"), "ㄇㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aooe"), "ㄇㄢˊ")
+    XCTAssertEqual(c.cS2RC("ap"), "ㄇㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aoor"), "ㄇㄢˇ")
+    XCTAssertEqual(c.cS2RC("ape"), "ㄇㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aood"), "ㄇㄢˋ")
+    XCTAssertEqual(c.cS2RC("apr"), "ㄇㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ap"), "ㄇㄣ")
+    XCTAssertEqual(c.cS2RC("apd"), "ㄇㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ape"), "ㄇㄣˊ")
+    XCTAssertEqual(c.cS2RC("apy"), "ㄇㄣ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("apr"), "ㄇㄣˇ")
+    XCTAssertEqual(c.cS2RC("all"), "ㄇㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("apd"), "ㄇㄣˋ")
+    XCTAssertEqual(c.cS2RC("alle"), "ㄇㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("apy"), "ㄇㄣ˙")
+    XCTAssertEqual(c.cS2RC("allr"), "ㄇㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("all"), "ㄇㄤ")
+    XCTAssertEqual(c.cS2RC("alld"), "ㄇㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("alle"), "ㄇㄤˊ")
+    XCTAssertEqual(c.cS2RC("an"), "ㄇㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("allr"), "ㄇㄤˇ")
+    XCTAssertEqual(c.cS2RC("ane"), "ㄇㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("alld"), "ㄇㄤˋ")
+    XCTAssertEqual(c.cS2RC("anr"), "ㄇㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("an"), "ㄇㄥ")
+    XCTAssertEqual(c.cS2RC("and"), "ㄇㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ane"), "ㄇㄥˊ")
+    XCTAssertEqual(c.cS2RC("au"), "ㄇㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("anr"), "ㄇㄥˇ")
+    XCTAssertEqual(c.cS2RC("aue"), "ㄇㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("and"), "ㄇㄥˋ")
+    XCTAssertEqual(c.cS2RC("aur"), "ㄇㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("au"), "ㄇㄧ")
+    XCTAssertEqual(c.cS2RC("aud"), "ㄇㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aue"), "ㄇㄧˊ")
+    XCTAssertEqual(c.cS2RC("aub"), "ㄇㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aur"), "ㄇㄧˇ")
+    XCTAssertEqual(c.cS2RC("aube"), "ㄇㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aud"), "ㄇㄧˋ")
+    XCTAssertEqual(c.cS2RC("aubd"), "ㄇㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aub"), "ㄇㄧㄝ")
+    XCTAssertEqual(c.cS2RC("aul"), "ㄇㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aube"), "ㄇㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("aule"), "ㄇㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aubd"), "ㄇㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("aulr"), "ㄇㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aul"), "ㄇㄧㄠ")
+    XCTAssertEqual(c.cS2RC("auld"), "ㄇㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aule"), "ㄇㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("aume"), "ㄇㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aulr"), "ㄇㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("aumr"), "ㄇㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auld"), "ㄇㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("aumd"), "ㄇㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aume"), "ㄇㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("auoo"), "ㄇㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aumr"), "ㄇㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("auooe"), "ㄇㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aumd"), "ㄇㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("auoor"), "ㄇㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auoo"), "ㄇㄧㄢ")
+    XCTAssertEqual(c.cS2RC("auood"), "ㄇㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auooe"), "ㄇㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("aup"), "ㄇㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auoor"), "ㄇㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("aupe"), "ㄇㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("auood"), "ㄇㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("aupr"), "ㄇㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aup"), "ㄇㄧㄣ")
+    XCTAssertEqual(c.cS2RC("aune"), "ㄇㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aupe"), "ㄇㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("aunr"), "ㄇㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aupr"), "ㄇㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("aund"), "ㄇㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aune"), "ㄇㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("aje"), "ㄇㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aunr"), "ㄇㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("ajr"), "ㄇㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aund"), "ㄇㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("ajd"), "ㄇㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("aje"), "ㄇㄨˊ")
+    XCTAssertEqual(c.cS2RC("zuu"), "ㄈㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ajr"), "ㄇㄨˇ")
+    XCTAssertEqual(c.cS2RC("zuue"), "ㄈㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ajd"), "ㄇㄨˋ")
+    XCTAssertEqual(c.cS2RC("zuur"), "ㄈㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zuu"), "ㄈㄚ")
+    XCTAssertEqual(c.cS2RC("zuud"), "ㄈㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zuue"), "ㄈㄚˊ")
+    XCTAssertEqual(c.cS2RC("zie"), "ㄈㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zuur"), "ㄈㄚˇ")
+    XCTAssertEqual(c.cS2RC("zo"), "ㄈㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zuud"), "ㄈㄚˋ")
+    XCTAssertEqual(c.cS2RC("zoe"), "ㄈㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zie"), "ㄈㄛˊ")
+    XCTAssertEqual(c.cS2RC("zor"), "ㄈㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zo"), "ㄈㄟ")
+    XCTAssertEqual(c.cS2RC("zod"), "ㄈㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zoe"), "ㄈㄟˊ")
+    XCTAssertEqual(c.cS2RC("zm"), "ㄈㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zor"), "ㄈㄟˇ")
+    XCTAssertEqual(c.cS2RC("zme"), "ㄈㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zod"), "ㄈㄟˋ")
+    XCTAssertEqual(c.cS2RC("zmr"), "ㄈㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zm"), "ㄈㄡ")
+    XCTAssertEqual(c.cS2RC("zmd"), "ㄈㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zme"), "ㄈㄡˊ")
+    XCTAssertEqual(c.cS2RC("zoo"), "ㄈㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zmr"), "ㄈㄡˇ")
+    XCTAssertEqual(c.cS2RC("zooe"), "ㄈㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zmd"), "ㄈㄡˋ")
+    XCTAssertEqual(c.cS2RC("zoor"), "ㄈㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zoo"), "ㄈㄢ")
+    XCTAssertEqual(c.cS2RC("zood"), "ㄈㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zooe"), "ㄈㄢˊ")
+    XCTAssertEqual(c.cS2RC("zp"), "ㄈㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zoor"), "ㄈㄢˇ")
+    XCTAssertEqual(c.cS2RC("zpe"), "ㄈㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zood"), "ㄈㄢˋ")
+    XCTAssertEqual(c.cS2RC("zpr"), "ㄈㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zp"), "ㄈㄣ")
+    XCTAssertEqual(c.cS2RC("zpd"), "ㄈㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zpe"), "ㄈㄣˊ")
+    XCTAssertEqual(c.cS2RC("zpy"), "ㄈㄣ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zpr"), "ㄈㄣˇ")
+    XCTAssertEqual(c.cS2RC("zll"), "ㄈㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zpd"), "ㄈㄣˋ")
+    XCTAssertEqual(c.cS2RC("zlle"), "ㄈㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zpy"), "ㄈㄣ˙")
+    XCTAssertEqual(c.cS2RC("zllr"), "ㄈㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zll"), "ㄈㄤ")
+    XCTAssertEqual(c.cS2RC("zlld"), "ㄈㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zlle"), "ㄈㄤˊ")
+    XCTAssertEqual(c.cS2RC("zn"), "ㄈㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zllr"), "ㄈㄤˇ")
+    XCTAssertEqual(c.cS2RC("zne"), "ㄈㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zlld"), "ㄈㄤˋ")
+    XCTAssertEqual(c.cS2RC("znr"), "ㄈㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zn"), "ㄈㄥ")
+    XCTAssertEqual(c.cS2RC("znd"), "ㄈㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zne"), "ㄈㄥˊ")
+    XCTAssertEqual(c.cS2RC("zuld"), "ㄈㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("znr"), "ㄈㄥˇ")
+    XCTAssertEqual(c.cS2RC("zj"), "ㄈㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("znd"), "ㄈㄥˋ")
+    XCTAssertEqual(c.cS2RC("zje"), "ㄈㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zuld"), "ㄈㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("zjr"), "ㄈㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zj"), "ㄈㄨ")
+    XCTAssertEqual(c.cS2RC("zjd"), "ㄈㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zje"), "ㄈㄨˊ")
+    XCTAssertEqual(c.cS2RC("wwuu"), "ㄉㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zjr"), "ㄈㄨˇ")
+    XCTAssertEqual(c.cS2RC("wwuue"), "ㄉㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("zjd"), "ㄈㄨˋ")
+    XCTAssertEqual(c.cS2RC("wwuur"), "ㄉㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuu"), "ㄉㄚ")
+    XCTAssertEqual(c.cS2RC("wwuud"), "ㄉㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuue"), "ㄉㄚˊ")
+    XCTAssertEqual(c.cS2RC("wwuuy"), "ㄉㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuur"), "ㄉㄚˇ")
+    XCTAssertEqual(c.cS2RC("wwk"), "ㄉㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuud"), "ㄉㄚˋ")
+    XCTAssertEqual(c.cS2RC("wwke"), "ㄉㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuuy"), "ㄉㄚ˙")
+    XCTAssertEqual(c.cS2RC("wwky"), "ㄉㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwk"), "ㄉㄜ")
+    XCTAssertEqual(c.cS2RC("wwii"), "ㄉㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwke"), "ㄉㄜˊ")
+    XCTAssertEqual(c.cS2RC("wwiir"), "ㄉㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwky"), "ㄉㄜ˙")
+    XCTAssertEqual(c.cS2RC("wwiid"), "ㄉㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwii"), "ㄉㄞ")
+    XCTAssertEqual(c.cS2RC("wwor"), "ㄉㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwiir"), "ㄉㄞˇ")
+    XCTAssertEqual(c.cS2RC("wwl"), "ㄉㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwiid"), "ㄉㄞˋ")
+    XCTAssertEqual(c.cS2RC("wwle"), "ㄉㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwor"), "ㄉㄟˇ")
+    XCTAssertEqual(c.cS2RC("wwlr"), "ㄉㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwl"), "ㄉㄠ")
+    XCTAssertEqual(c.cS2RC("wwld"), "ㄉㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwle"), "ㄉㄠˊ")
+    XCTAssertEqual(c.cS2RC("wwm"), "ㄉㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwlr"), "ㄉㄠˇ")
+    XCTAssertEqual(c.cS2RC("wwme"), "ㄉㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwld"), "ㄉㄠˋ")
+    XCTAssertEqual(c.cS2RC("wwmr"), "ㄉㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwm"), "ㄉㄡ")
+    XCTAssertEqual(c.cS2RC("wwmd"), "ㄉㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwme"), "ㄉㄡˊ")
+    XCTAssertEqual(c.cS2RC("wwoo"), "ㄉㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwmr"), "ㄉㄡˇ")
+    XCTAssertEqual(c.cS2RC("wwoor"), "ㄉㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwmd"), "ㄉㄡˋ")
+    XCTAssertEqual(c.cS2RC("wwood"), "ㄉㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwoo"), "ㄉㄢ")
+    XCTAssertEqual(c.cS2RC("wwpd"), "ㄉㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwoor"), "ㄉㄢˇ")
+    XCTAssertEqual(c.cS2RC("wwll"), "ㄉㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwood"), "ㄉㄢˋ")
+    XCTAssertEqual(c.cS2RC("wwllr"), "ㄉㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwpd"), "ㄉㄣˋ")
+    XCTAssertEqual(c.cS2RC("wwlld"), "ㄉㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwll"), "ㄉㄤ")
+    XCTAssertEqual(c.cS2RC("wwn"), "ㄉㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwllr"), "ㄉㄤˇ")
+    XCTAssertEqual(c.cS2RC("wwnr"), "ㄉㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwlld"), "ㄉㄤˋ")
+    XCTAssertEqual(c.cS2RC("wwnd"), "ㄉㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwn"), "ㄉㄥ")
+    XCTAssertEqual(c.cS2RC("wwu"), "ㄉㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwnr"), "ㄉㄥˇ")
+    XCTAssertEqual(c.cS2RC("wwue"), "ㄉㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwnd"), "ㄉㄥˋ")
+    XCTAssertEqual(c.cS2RC("wwur"), "ㄉㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwu"), "ㄉㄧ")
+    XCTAssertEqual(c.cS2RC("wwud"), "ㄉㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwue"), "ㄉㄧˊ")
+    XCTAssertEqual(c.cS2RC("wwuuur"), "ㄉㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwur"), "ㄉㄧˇ")
+    XCTAssertEqual(c.cS2RC("wwub"), "ㄉㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwud"), "ㄉㄧˋ")
+    XCTAssertEqual(c.cS2RC("wwube"), "ㄉㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuuur"), "ㄉㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("wwubr"), "ㄉㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwub"), "ㄉㄧㄝ")
+    XCTAssertEqual(c.cS2RC("wwubd"), "ㄉㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwube"), "ㄉㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("wwul"), "ㄉㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwubr"), "ㄉㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("wwulr"), "ㄉㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwubd"), "ㄉㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("wwuld"), "ㄉㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwul"), "ㄉㄧㄠ")
+    XCTAssertEqual(c.cS2RC("wwum"), "ㄉㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwulr"), "ㄉㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("wwuoo"), "ㄉㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuld"), "ㄉㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("wwuooe"), "ㄉㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwum"), "ㄉㄧㄡ")
+    XCTAssertEqual(c.cS2RC("wwuoor"), "ㄉㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuoo"), "ㄉㄧㄢ")
+    XCTAssertEqual(c.cS2RC("wwuood"), "ㄉㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuooe"), "ㄉㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("wwun"), "ㄉㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuoor"), "ㄉㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("wwune"), "ㄉㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwuood"), "ㄉㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("wwunr"), "ㄉㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwun"), "ㄉㄧㄥ")
+    XCTAssertEqual(c.cS2RC("wwund"), "ㄉㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwune"), "ㄉㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("wwj"), "ㄉㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwunr"), "ㄉㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("wwje"), "ㄉㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwund"), "ㄉㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("wwjr"), "ㄉㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwj"), "ㄉㄨ")
+    XCTAssertEqual(c.cS2RC("wwjd"), "ㄉㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwje"), "ㄉㄨˊ")
+    XCTAssertEqual(c.cS2RC("wwji"), "ㄉㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjr"), "ㄉㄨˇ")
+    XCTAssertEqual(c.cS2RC("wwjie"), "ㄉㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjd"), "ㄉㄨˋ")
+    XCTAssertEqual(c.cS2RC("wwjir"), "ㄉㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwji"), "ㄉㄨㄛ")
+    XCTAssertEqual(c.cS2RC("wwjid"), "ㄉㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjie"), "ㄉㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("wwjiy"), "ㄉㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjir"), "ㄉㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("wwjo"), "ㄉㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjid"), "ㄉㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("wwjor"), "ㄉㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjiy"), "ㄉㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("wwjod"), "ㄉㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjo"), "ㄉㄨㄟ")
+    XCTAssertEqual(c.cS2RC("wwjoo"), "ㄉㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjor"), "ㄉㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("wwjoor"), "ㄉㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjod"), "ㄉㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("wwjood"), "ㄉㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjoo"), "ㄉㄨㄢ")
+    XCTAssertEqual(c.cS2RC("wwjp"), "ㄉㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjoor"), "ㄉㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("wwjpr"), "ㄉㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjood"), "ㄉㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("wwjpd"), "ㄉㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjp"), "ㄉㄨㄣ")
+    XCTAssertEqual(c.cS2RC("wwjn"), "ㄉㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjpr"), "ㄉㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("wwjnr"), "ㄉㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjpd"), "ㄉㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("wwjnd"), "ㄉㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjn"), "ㄉㄨㄥ")
+    XCTAssertEqual(c.cS2RC("wuu"), "ㄊㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjnr"), "ㄉㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("wuur"), "ㄊㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wwjnd"), "ㄉㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("wuud"), "ㄊㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wuu"), "ㄊㄚ")
+    XCTAssertEqual(c.cS2RC("wkd"), "ㄊㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wuur"), "ㄊㄚˇ")
+    XCTAssertEqual(c.cS2RC("wii"), "ㄊㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wuud"), "ㄊㄚˋ")
+    XCTAssertEqual(c.cS2RC("wiie"), "ㄊㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wkd"), "ㄊㄜˋ")
+    XCTAssertEqual(c.cS2RC("wiir"), "ㄊㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wii"), "ㄊㄞ")
+    XCTAssertEqual(c.cS2RC("wiid"), "ㄊㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wiie"), "ㄊㄞˊ")
+    XCTAssertEqual(c.cS2RC("wiiy"), "ㄊㄞ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wiir"), "ㄊㄞˇ")
+    XCTAssertEqual(c.cS2RC("wl"), "ㄊㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wiid"), "ㄊㄞˋ")
+    XCTAssertEqual(c.cS2RC("wle"), "ㄊㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wiiy"), "ㄊㄞ˙")
+    XCTAssertEqual(c.cS2RC("wlr"), "ㄊㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wl"), "ㄊㄠ")
+    XCTAssertEqual(c.cS2RC("wld"), "ㄊㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wle"), "ㄊㄠˊ")
+    XCTAssertEqual(c.cS2RC("wly"), "ㄊㄠ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wlr"), "ㄊㄠˇ")
+    XCTAssertEqual(c.cS2RC("wm"), "ㄊㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wld"), "ㄊㄠˋ")
+    XCTAssertEqual(c.cS2RC("wme"), "ㄊㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wly"), "ㄊㄠ˙")
+    XCTAssertEqual(c.cS2RC("wmr"), "ㄊㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wm"), "ㄊㄡ")
+    XCTAssertEqual(c.cS2RC("wmd"), "ㄊㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wme"), "ㄊㄡˊ")
+    XCTAssertEqual(c.cS2RC("wmy"), "ㄊㄡ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wmr"), "ㄊㄡˇ")
+    XCTAssertEqual(c.cS2RC("woo"), "ㄊㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wmd"), "ㄊㄡˋ")
+    XCTAssertEqual(c.cS2RC("wooe"), "ㄊㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wmy"), "ㄊㄡ˙")
+    XCTAssertEqual(c.cS2RC("woor"), "ㄊㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("woo"), "ㄊㄢ")
+    XCTAssertEqual(c.cS2RC("wood"), "ㄊㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wooe"), "ㄊㄢˊ")
+    XCTAssertEqual(c.cS2RC("wll"), "ㄊㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("woor"), "ㄊㄢˇ")
+    XCTAssertEqual(c.cS2RC("wlle"), "ㄊㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wood"), "ㄊㄢˋ")
+    XCTAssertEqual(c.cS2RC("wllr"), "ㄊㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wll"), "ㄊㄤ")
+    XCTAssertEqual(c.cS2RC("wlld"), "ㄊㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wlle"), "ㄊㄤˊ")
+    XCTAssertEqual(c.cS2RC("wn"), "ㄊㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wllr"), "ㄊㄤˇ")
+    XCTAssertEqual(c.cS2RC("wne"), "ㄊㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wlld"), "ㄊㄤˋ")
+    XCTAssertEqual(c.cS2RC("wnd"), "ㄊㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wn"), "ㄊㄥ")
+    XCTAssertEqual(c.cS2RC("wu"), "ㄊㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wne"), "ㄊㄥˊ")
+    XCTAssertEqual(c.cS2RC("wue"), "ㄊㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wnd"), "ㄊㄥˋ")
+    XCTAssertEqual(c.cS2RC("wur"), "ㄊㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wu"), "ㄊㄧ")
+    XCTAssertEqual(c.cS2RC("wud"), "ㄊㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wue"), "ㄊㄧˊ")
+    XCTAssertEqual(c.cS2RC("wub"), "ㄊㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wur"), "ㄊㄧˇ")
+    XCTAssertEqual(c.cS2RC("wube"), "ㄊㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wud"), "ㄊㄧˋ")
+    XCTAssertEqual(c.cS2RC("wubr"), "ㄊㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wub"), "ㄊㄧㄝ")
+    XCTAssertEqual(c.cS2RC("wubd"), "ㄊㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wube"), "ㄊㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("wul"), "ㄊㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wubr"), "ㄊㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("wule"), "ㄊㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wubd"), "ㄊㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("wulr"), "ㄊㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wul"), "ㄊㄧㄠ")
+    XCTAssertEqual(c.cS2RC("wuld"), "ㄊㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wule"), "ㄊㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("wuoo"), "ㄊㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wulr"), "ㄊㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("wuooe"), "ㄊㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wuld"), "ㄊㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("wuoor"), "ㄊㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wuoo"), "ㄊㄧㄢ")
+    XCTAssertEqual(c.cS2RC("wuood"), "ㄊㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wuooe"), "ㄊㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("wun"), "ㄊㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wuoor"), "ㄊㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("wune"), "ㄊㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wuood"), "ㄊㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("wunr"), "ㄊㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wun"), "ㄊㄧㄥ")
+    XCTAssertEqual(c.cS2RC("wund"), "ㄊㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wune"), "ㄊㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("wj"), "ㄊㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wunr"), "ㄊㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("wje"), "ㄊㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wund"), "ㄊㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("wjr"), "ㄊㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wj"), "ㄊㄨ")
+    XCTAssertEqual(c.cS2RC("wjd"), "ㄊㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wje"), "ㄊㄨˊ")
+    XCTAssertEqual(c.cS2RC("wji"), "ㄊㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjr"), "ㄊㄨˇ")
+    XCTAssertEqual(c.cS2RC("wjie"), "ㄊㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjd"), "ㄊㄨˋ")
+    XCTAssertEqual(c.cS2RC("wjir"), "ㄊㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wji"), "ㄊㄨㄛ")
+    XCTAssertEqual(c.cS2RC("wjid"), "ㄊㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjie"), "ㄊㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("wjo"), "ㄊㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjir"), "ㄊㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("wjoe"), "ㄊㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjid"), "ㄊㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("wjor"), "ㄊㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjo"), "ㄊㄨㄟ")
+    XCTAssertEqual(c.cS2RC("wjod"), "ㄊㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjoe"), "ㄊㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("wjoo"), "ㄊㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjor"), "ㄊㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("wjooe"), "ㄊㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjod"), "ㄊㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("wjoor"), "ㄊㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjoo"), "ㄊㄨㄢ")
+    XCTAssertEqual(c.cS2RC("wjood"), "ㄊㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjooe"), "ㄊㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("wjp"), "ㄊㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjoor"), "ㄊㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("wjpe"), "ㄊㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjood"), "ㄊㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("wjpr"), "ㄊㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjp"), "ㄊㄨㄣ")
+    XCTAssertEqual(c.cS2RC("wjpd"), "ㄊㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjpe"), "ㄊㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("wjn"), "ㄊㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjpr"), "ㄊㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("wjne"), "ㄊㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjpd"), "ㄊㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("wjnr"), "ㄊㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjn"), "ㄊㄨㄥ")
+    XCTAssertEqual(c.cS2RC("wjnd"), "ㄊㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjne"), "ㄊㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("suu"), "ㄋㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjnr"), "ㄊㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("suue"), "ㄋㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("wjnd"), "ㄊㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("suur"), "ㄋㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suu"), "ㄋㄚ")
+    XCTAssertEqual(c.cS2RC("suud"), "ㄋㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suue"), "ㄋㄚˊ")
+    XCTAssertEqual(c.cS2RC("suuy"), "ㄋㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suur"), "ㄋㄚˇ")
+    XCTAssertEqual(c.cS2RC("skd"), "ㄋㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suud"), "ㄋㄚˋ")
+    XCTAssertEqual(c.cS2RC("sky"), "ㄋㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suuy"), "ㄋㄚ˙")
+    XCTAssertEqual(c.cS2RC("siie"), "ㄋㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("skd"), "ㄋㄜˋ")
+    XCTAssertEqual(c.cS2RC("siir"), "ㄋㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sky"), "ㄋㄜ˙")
+    XCTAssertEqual(c.cS2RC("siid"), "ㄋㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("siie"), "ㄋㄞˊ")
+    XCTAssertEqual(c.cS2RC("soe"), "ㄋㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("siir"), "ㄋㄞˇ")
+    XCTAssertEqual(c.cS2RC("sor"), "ㄋㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("siid"), "ㄋㄞˋ")
+    XCTAssertEqual(c.cS2RC("sod"), "ㄋㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("soe"), "ㄋㄟˊ")
+    XCTAssertEqual(c.cS2RC("sl"), "ㄋㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sor"), "ㄋㄟˇ")
+    XCTAssertEqual(c.cS2RC("sle"), "ㄋㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sod"), "ㄋㄟˋ")
+    XCTAssertEqual(c.cS2RC("slr"), "ㄋㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sl"), "ㄋㄠ")
+    XCTAssertEqual(c.cS2RC("sld"), "ㄋㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sle"), "ㄋㄠˊ")
+    XCTAssertEqual(c.cS2RC("sme"), "ㄋㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("slr"), "ㄋㄠˇ")
+    XCTAssertEqual(c.cS2RC("smr"), "ㄋㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sld"), "ㄋㄠˋ")
+    XCTAssertEqual(c.cS2RC("smd"), "ㄋㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sme"), "ㄋㄡˊ")
+    XCTAssertEqual(c.cS2RC("soo"), "ㄋㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("smr"), "ㄋㄡˇ")
+    XCTAssertEqual(c.cS2RC("sooe"), "ㄋㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("smd"), "ㄋㄡˋ")
+    XCTAssertEqual(c.cS2RC("soor"), "ㄋㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("soo"), "ㄋㄢ")
+    XCTAssertEqual(c.cS2RC("sood"), "ㄋㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sooe"), "ㄋㄢˊ")
+    XCTAssertEqual(c.cS2RC("spr"), "ㄋㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("soor"), "ㄋㄢˇ")
+    XCTAssertEqual(c.cS2RC("spd"), "ㄋㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sood"), "ㄋㄢˋ")
+    XCTAssertEqual(c.cS2RC("sll"), "ㄋㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("spr"), "ㄋㄣˇ")
+    XCTAssertEqual(c.cS2RC("slle"), "ㄋㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("spd"), "ㄋㄣˋ")
+    XCTAssertEqual(c.cS2RC("sllr"), "ㄋㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sll"), "ㄋㄤ")
+    XCTAssertEqual(c.cS2RC("slld"), "ㄋㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("slle"), "ㄋㄤˊ")
+    XCTAssertEqual(c.cS2RC("slly"), "ㄋㄤ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sllr"), "ㄋㄤˇ")
+    XCTAssertEqual(c.cS2RC("sne"), "ㄋㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("slld"), "ㄋㄤˋ")
+    XCTAssertEqual(c.cS2RC("snr"), "ㄋㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("slly"), "ㄋㄤ˙")
+    XCTAssertEqual(c.cS2RC("su"), "ㄋㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sne"), "ㄋㄥˊ")
+    XCTAssertEqual(c.cS2RC("sue"), "ㄋㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("snr"), "ㄋㄥˇ")
+    XCTAssertEqual(c.cS2RC("sur"), "ㄋㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("su"), "ㄋㄧ")
+    XCTAssertEqual(c.cS2RC("sud"), "ㄋㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sue"), "ㄋㄧˊ")
+    XCTAssertEqual(c.cS2RC("sub"), "ㄋㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sur"), "ㄋㄧˇ")
+    XCTAssertEqual(c.cS2RC("sube"), "ㄋㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sud"), "ㄋㄧˋ")
+    XCTAssertEqual(c.cS2RC("subd"), "ㄋㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sub"), "ㄋㄧㄝ")
+    XCTAssertEqual(c.cS2RC("sulr"), "ㄋㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sube"), "ㄋㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("suld"), "ㄋㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("subd"), "ㄋㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("sum"), "ㄋㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sulr"), "ㄋㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("sume"), "ㄋㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suld"), "ㄋㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("sumr"), "ㄋㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sum"), "ㄋㄧㄡ")
+    XCTAssertEqual(c.cS2RC("sumd"), "ㄋㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sume"), "ㄋㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("suoo"), "ㄋㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sumr"), "ㄋㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("suooe"), "ㄋㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sumd"), "ㄋㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("suoor"), "ㄋㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suoo"), "ㄋㄧㄢ")
+    XCTAssertEqual(c.cS2RC("suood"), "ㄋㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suooe"), "ㄋㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("sup"), "ㄋㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suoor"), "ㄋㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("supe"), "ㄋㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("suood"), "ㄋㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("supr"), "ㄋㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sup"), "ㄋㄧㄣ")
+    XCTAssertEqual(c.cS2RC("supd"), "ㄋㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("supe"), "ㄋㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("sulle"), "ㄋㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("supr"), "ㄋㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("sullr"), "ㄋㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("supd"), "ㄋㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("sulld"), "ㄋㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sulle"), "ㄋㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("sune"), "ㄋㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sullr"), "ㄋㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("sunr"), "ㄋㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sulld"), "ㄋㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("sund"), "ㄋㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sune"), "ㄋㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("sje"), "ㄋㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sunr"), "ㄋㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("sjr"), "ㄋㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sund"), "ㄋㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("sjd"), "ㄋㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sje"), "ㄋㄨˊ")
+    XCTAssertEqual(c.cS2RC("sjie"), "ㄋㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjr"), "ㄋㄨˇ")
+    XCTAssertEqual(c.cS2RC("sjir"), "ㄋㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjd"), "ㄋㄨˋ")
+    XCTAssertEqual(c.cS2RC("sjid"), "ㄋㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjie"), "ㄋㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("sjoe"), "ㄋㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjir"), "ㄋㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("sjooe"), "ㄋㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjid"), "ㄋㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("sjoor"), "ㄋㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjoe"), "ㄋㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("sjood"), "ㄋㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjooe"), "ㄋㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("sjpe"), "ㄋㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjoor"), "ㄋㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("sjne"), "ㄋㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjood"), "ㄋㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("sjnr"), "ㄋㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjpe"), "ㄋㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("sjnd"), "ㄋㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjne"), "ㄋㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("smme"), "ㄋㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjnr"), "ㄋㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("smmr"), "ㄋㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("sjnd"), "ㄋㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("smmd"), "ㄋㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("smme"), "ㄋㄩˊ")
+    XCTAssertEqual(c.cS2RC("smmbd"), "ㄋㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("smmr"), "ㄋㄩˇ")
+    XCTAssertEqual(c.cS2RC("xuu"), "ㄌㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("smmd"), "ㄋㄩˋ")
+    XCTAssertEqual(c.cS2RC("xuue"), "ㄌㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("smmbd"), "ㄋㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("xuur"), "ㄌㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuu"), "ㄌㄚ")
+    XCTAssertEqual(c.cS2RC("xuud"), "ㄌㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuue"), "ㄌㄚˊ")
+    XCTAssertEqual(c.cS2RC("xuuy"), "ㄌㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuur"), "ㄌㄚˇ")
+    XCTAssertEqual(c.cS2RC("xi"), "ㄌㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuud"), "ㄌㄚˋ")
+    XCTAssertEqual(c.cS2RC("xiy"), "ㄌㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuuy"), "ㄌㄚ˙")
+    XCTAssertEqual(c.cS2RC("xk"), "ㄌㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xi"), "ㄌㄛ")
+    XCTAssertEqual(c.cS2RC("xke"), "ㄌㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xiy"), "ㄌㄛ˙")
+    XCTAssertEqual(c.cS2RC("xkd"), "ㄌㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xk"), "ㄌㄜ")
+    XCTAssertEqual(c.cS2RC("xky"), "ㄌㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xke"), "ㄌㄜˊ")
+    XCTAssertEqual(c.cS2RC("xiie"), "ㄌㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xkd"), "ㄌㄜˋ")
+    XCTAssertEqual(c.cS2RC("xiir"), "ㄌㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xky"), "ㄌㄜ˙")
+    XCTAssertEqual(c.cS2RC("xiid"), "ㄌㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xiie"), "ㄌㄞˊ")
+    XCTAssertEqual(c.cS2RC("xo"), "ㄌㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xiir"), "ㄌㄞˇ")
+    XCTAssertEqual(c.cS2RC("xoe"), "ㄌㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xiid"), "ㄌㄞˋ")
+    XCTAssertEqual(c.cS2RC("xor"), "ㄌㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xo"), "ㄌㄟ")
+    XCTAssertEqual(c.cS2RC("xod"), "ㄌㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xoe"), "ㄌㄟˊ")
+    XCTAssertEqual(c.cS2RC("xoy"), "ㄌㄟ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xor"), "ㄌㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xod"), "ㄌㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xoy"), "ㄌㄟ˙")
   }
 }

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Dachen26_B.swift

@@ -12,491 +12,491 @@ import XCTest
 
 extension TekkonTestsKeyboardArrangments {
   func testDachen26KeysB() throws {
-    var composer = Tekkon.Composer(arrange: .ofDachen26)
+    var c = Tekkon.Composer(arrange: .ofDachen26)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xl"), "ㄌㄠ")
+    XCTAssertEqual(c.cS2RC("xl"), "ㄌㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xle"), "ㄌㄠˊ")
+    XCTAssertEqual(c.cS2RC("xle"), "ㄌㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xlr"), "ㄌㄠˇ")
+    XCTAssertEqual(c.cS2RC("xlr"), "ㄌㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xld"), "ㄌㄠˋ")
+    XCTAssertEqual(c.cS2RC("xld"), "ㄌㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xm"), "ㄌㄡ")
+    XCTAssertEqual(c.cS2RC("xm"), "ㄌㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xme"), "ㄌㄡˊ")
+    XCTAssertEqual(c.cS2RC("xme"), "ㄌㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmr"), "ㄌㄡˇ")
+    XCTAssertEqual(c.cS2RC("xmr"), "ㄌㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmd"), "ㄌㄡˋ")
+    XCTAssertEqual(c.cS2RC("xmd"), "ㄌㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmy"), "ㄌㄡ˙")
+    XCTAssertEqual(c.cS2RC("xmy"), "ㄌㄡ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xooe"), "ㄌㄢˊ")
+    XCTAssertEqual(c.cS2RC("xooe"), "ㄌㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xoor"), "ㄌㄢˇ")
+    XCTAssertEqual(c.cS2RC("xoor"), "ㄌㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xood"), "ㄌㄢˋ")
+    XCTAssertEqual(c.cS2RC("xood"), "ㄌㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xll"), "ㄌㄤ")
+    XCTAssertEqual(c.cS2RC("xll"), "ㄌㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xlle"), "ㄌㄤˊ")
+    XCTAssertEqual(c.cS2RC("xlle"), "ㄌㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xllr"), "ㄌㄤˇ")
+    XCTAssertEqual(c.cS2RC("xllr"), "ㄌㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xlld"), "ㄌㄤˋ")
+    XCTAssertEqual(c.cS2RC("xlld"), "ㄌㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xn"), "ㄌㄥ")
+    XCTAssertEqual(c.cS2RC("xn"), "ㄌㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xne"), "ㄌㄥˊ")
+    XCTAssertEqual(c.cS2RC("xne"), "ㄌㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xnr"), "ㄌㄥˇ")
+    XCTAssertEqual(c.cS2RC("xnr"), "ㄌㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xnd"), "ㄌㄥˋ")
+    XCTAssertEqual(c.cS2RC("xnd"), "ㄌㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xu"), "ㄌㄧ")
+    XCTAssertEqual(c.cS2RC("xu"), "ㄌㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xue"), "ㄌㄧˊ")
+    XCTAssertEqual(c.cS2RC("xue"), "ㄌㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xur"), "ㄌㄧˇ")
+    XCTAssertEqual(c.cS2RC("xur"), "ㄌㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xud"), "ㄌㄧˋ")
+    XCTAssertEqual(c.cS2RC("xud"), "ㄌㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuy"), "ㄌㄧ˙")
+    XCTAssertEqual(c.cS2RC("xuy"), "ㄌㄧ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuuur"), "ㄌㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("xuuur"), "ㄌㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xub"), "ㄌㄧㄝ")
+    XCTAssertEqual(c.cS2RC("xub"), "ㄌㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xube"), "ㄌㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("xube"), "ㄌㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xubr"), "ㄌㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("xubr"), "ㄌㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xubd"), "ㄌㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("xubd"), "ㄌㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xul"), "ㄌㄧㄠ")
+    XCTAssertEqual(c.cS2RC("xul"), "ㄌㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xule"), "ㄌㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("xule"), "ㄌㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xulr"), "ㄌㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("xulr"), "ㄌㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuld"), "ㄌㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("xuld"), "ㄌㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xum"), "ㄌㄧㄡ")
+    XCTAssertEqual(c.cS2RC("xum"), "ㄌㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xume"), "ㄌㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("xume"), "ㄌㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xumr"), "ㄌㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("xumr"), "ㄌㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xumd"), "ㄌㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("xumd"), "ㄌㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuoo"), "ㄌㄧㄢ")
+    XCTAssertEqual(c.cS2RC("xuoo"), "ㄌㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuooe"), "ㄌㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("xuooe"), "ㄌㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuoor"), "ㄌㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("xuoor"), "ㄌㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xuood"), "ㄌㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("xuood"), "ㄌㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xupe"), "ㄌㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("xupe"), "ㄌㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xupr"), "ㄌㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("xupr"), "ㄌㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xupd"), "ㄌㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("xupd"), "ㄌㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xulle"), "ㄌㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("xulle"), "ㄌㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xullr"), "ㄌㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("xullr"), "ㄌㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xulld"), "ㄌㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("xulld"), "ㄌㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xun"), "ㄌㄧㄥ")
+    XCTAssertEqual(c.cS2RC("xun"), "ㄌㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xune"), "ㄌㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("xune"), "ㄌㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xunr"), "ㄌㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("xunr"), "ㄌㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xund"), "ㄌㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("xund"), "ㄌㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xj"), "ㄌㄨ")
+    XCTAssertEqual(c.cS2RC("xj"), "ㄌㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xje"), "ㄌㄨˊ")
+    XCTAssertEqual(c.cS2RC("xje"), "ㄌㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjr"), "ㄌㄨˇ")
+    XCTAssertEqual(c.cS2RC("xjr"), "ㄌㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjd"), "ㄌㄨˋ")
+    XCTAssertEqual(c.cS2RC("xjd"), "ㄌㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xji"), "ㄌㄨㄛ")
+    XCTAssertEqual(c.cS2RC("xji"), "ㄌㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjie"), "ㄌㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("xjie"), "ㄌㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjir"), "ㄌㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("xjir"), "ㄌㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjid"), "ㄌㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("xjid"), "ㄌㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjiy"), "ㄌㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("xjiy"), "ㄌㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjooe"), "ㄌㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("xjooe"), "ㄌㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjoor"), "ㄌㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("xjoor"), "ㄌㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjood"), "ㄌㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("xjood"), "ㄌㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjp"), "ㄌㄨㄣ")
+    XCTAssertEqual(c.cS2RC("xjp"), "ㄌㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjpe"), "ㄌㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("xjpe"), "ㄌㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjpr"), "ㄌㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("xjpr"), "ㄌㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjpd"), "ㄌㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("xjpd"), "ㄌㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjn"), "ㄌㄨㄥ")
+    XCTAssertEqual(c.cS2RC("xjn"), "ㄌㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjne"), "ㄌㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("xjne"), "ㄌㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjnr"), "ㄌㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("xjnr"), "ㄌㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xjnd"), "ㄌㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("xjnd"), "ㄌㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmm"), "ㄌㄩ")
+    XCTAssertEqual(c.cS2RC("xmm"), "ㄌㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmme"), "ㄌㄩˊ")
+    XCTAssertEqual(c.cS2RC("xmme"), "ㄌㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmmr"), "ㄌㄩˇ")
+    XCTAssertEqual(c.cS2RC("xmmr"), "ㄌㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmmd"), "ㄌㄩˋ")
+    XCTAssertEqual(c.cS2RC("xmmd"), "ㄌㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmmb"), "ㄌㄩㄝ")
+    XCTAssertEqual(c.cS2RC("xmmb"), "ㄌㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmmbr"), "ㄌㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("xmmbr"), "ㄌㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmmbd"), "ㄌㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("xmmbd"), "ㄌㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmmooe"), "ㄌㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("xmmooe"), "ㄌㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xmmoor"), "ㄌㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("xmmoor"), "ㄌㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("euu"), "ㄍㄚ")
+    XCTAssertEqual(c.cS2RC("euu"), "ㄍㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("euue"), "ㄍㄚˊ")
+    XCTAssertEqual(c.cS2RC("euue"), "ㄍㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("euur"), "ㄍㄚˇ")
+    XCTAssertEqual(c.cS2RC("euur"), "ㄍㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("euud"), "ㄍㄚˋ")
+    XCTAssertEqual(c.cS2RC("euud"), "ㄍㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("euuy"), "ㄍㄚ˙")
+    XCTAssertEqual(c.cS2RC("euuy"), "ㄍㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ek"), "ㄍㄜ")
+    XCTAssertEqual(c.cS2RC("ek"), "ㄍㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eke"), "ㄍㄜˊ")
+    XCTAssertEqual(c.cS2RC("eke"), "ㄍㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ekr"), "ㄍㄜˇ")
+    XCTAssertEqual(c.cS2RC("ekr"), "ㄍㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ekd"), "ㄍㄜˋ")
+    XCTAssertEqual(c.cS2RC("ekd"), "ㄍㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eky"), "ㄍㄜ˙")
+    XCTAssertEqual(c.cS2RC("eky"), "ㄍㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eii"), "ㄍㄞ")
+    XCTAssertEqual(c.cS2RC("eii"), "ㄍㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eiir"), "ㄍㄞˇ")
+    XCTAssertEqual(c.cS2RC("eiir"), "ㄍㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eiid"), "ㄍㄞˋ")
+    XCTAssertEqual(c.cS2RC("eiid"), "ㄍㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eor"), "ㄍㄟˇ")
+    XCTAssertEqual(c.cS2RC("eor"), "ㄍㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("el"), "ㄍㄠ")
+    XCTAssertEqual(c.cS2RC("el"), "ㄍㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("elr"), "ㄍㄠˇ")
+    XCTAssertEqual(c.cS2RC("elr"), "ㄍㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eld"), "ㄍㄠˋ")
+    XCTAssertEqual(c.cS2RC("eld"), "ㄍㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("em"), "ㄍㄡ")
+    XCTAssertEqual(c.cS2RC("em"), "ㄍㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("emr"), "ㄍㄡˇ")
+    XCTAssertEqual(c.cS2RC("emr"), "ㄍㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("emd"), "ㄍㄡˋ")
+    XCTAssertEqual(c.cS2RC("emd"), "ㄍㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eoo"), "ㄍㄢ")
+    XCTAssertEqual(c.cS2RC("eoo"), "ㄍㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eoor"), "ㄍㄢˇ")
+    XCTAssertEqual(c.cS2RC("eoor"), "ㄍㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eood"), "ㄍㄢˋ")
+    XCTAssertEqual(c.cS2RC("eood"), "ㄍㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ep"), "ㄍㄣ")
+    XCTAssertEqual(c.cS2RC("ep"), "ㄍㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("epe"), "ㄍㄣˊ")
+    XCTAssertEqual(c.cS2RC("epe"), "ㄍㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("epr"), "ㄍㄣˇ")
+    XCTAssertEqual(c.cS2RC("epr"), "ㄍㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("epd"), "ㄍㄣˋ")
+    XCTAssertEqual(c.cS2RC("epd"), "ㄍㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ell"), "ㄍㄤ")
+    XCTAssertEqual(c.cS2RC("ell"), "ㄍㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ellr"), "ㄍㄤˇ")
+    XCTAssertEqual(c.cS2RC("ellr"), "ㄍㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("elld"), "ㄍㄤˋ")
+    XCTAssertEqual(c.cS2RC("elld"), "ㄍㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("en"), "ㄍㄥ")
+    XCTAssertEqual(c.cS2RC("en"), "ㄍㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("enr"), "ㄍㄥˇ")
+    XCTAssertEqual(c.cS2RC("enr"), "ㄍㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("end"), "ㄍㄥˋ")
+    XCTAssertEqual(c.cS2RC("end"), "ㄍㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ej"), "ㄍㄨ")
+    XCTAssertEqual(c.cS2RC("ej"), "ㄍㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eje"), "ㄍㄨˊ")
+    XCTAssertEqual(c.cS2RC("eje"), "ㄍㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejr"), "ㄍㄨˇ")
+    XCTAssertEqual(c.cS2RC("ejr"), "ㄍㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejd"), "ㄍㄨˋ")
+    XCTAssertEqual(c.cS2RC("ejd"), "ㄍㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eju"), "ㄍㄨㄚ")
+    XCTAssertEqual(c.cS2RC("eju"), "ㄍㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejue"), "ㄍㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("ejue"), "ㄍㄨㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejur"), "ㄍㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("ejur"), "ㄍㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejud"), "ㄍㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("ejud"), "ㄍㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("eji"), "ㄍㄨㄛ")
+    XCTAssertEqual(c.cS2RC("eji"), "ㄍㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejie"), "ㄍㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("ejie"), "ㄍㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejir"), "ㄍㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("ejir"), "ㄍㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejid"), "ㄍㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("ejid"), "ㄍㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejii"), "ㄍㄨㄞ")
+    XCTAssertEqual(c.cS2RC("ejii"), "ㄍㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejiir"), "ㄍㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("ejiir"), "ㄍㄨㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejiid"), "ㄍㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("ejiid"), "ㄍㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejo"), "ㄍㄨㄟ")
+    XCTAssertEqual(c.cS2RC("ejo"), "ㄍㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejor"), "ㄍㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("ejor"), "ㄍㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejod"), "ㄍㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("ejod"), "ㄍㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejoo"), "ㄍㄨㄢ")
+    XCTAssertEqual(c.cS2RC("ejoo"), "ㄍㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejoor"), "ㄍㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("ejoor"), "ㄍㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejood"), "ㄍㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("ejood"), "ㄍㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejp"), "ㄍㄨㄣ")
+    XCTAssertEqual(c.cS2RC("ejp"), "ㄍㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejpr"), "ㄍㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("ejpr"), "ㄍㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejpd"), "ㄍㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("ejpd"), "ㄍㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejll"), "ㄍㄨㄤ")
+    XCTAssertEqual(c.cS2RC("ejll"), "ㄍㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejllr"), "ㄍㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("ejllr"), "ㄍㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejlld"), "ㄍㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("ejlld"), "ㄍㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejn"), "ㄍㄨㄥ")
+    XCTAssertEqual(c.cS2RC("ejn"), "ㄍㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejne"), "ㄍㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("ejne"), "ㄍㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejnr"), "ㄍㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("ejnr"), "ㄍㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ejnd"), "ㄍㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("ejnd"), "ㄍㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duu"), "ㄎㄚ")
+    XCTAssertEqual(c.cS2RC("duu"), "ㄎㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duur"), "ㄎㄚˇ")
+    XCTAssertEqual(c.cS2RC("duur"), "ㄎㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duud"), "ㄎㄚˋ")
+    XCTAssertEqual(c.cS2RC("duud"), "ㄎㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dk"), "ㄎㄜ")
+    XCTAssertEqual(c.cS2RC("dk"), "ㄎㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dke"), "ㄎㄜˊ")
+    XCTAssertEqual(c.cS2RC("dke"), "ㄎㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dkr"), "ㄎㄜˇ")
+    XCTAssertEqual(c.cS2RC("dkr"), "ㄎㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dkd"), "ㄎㄜˋ")
+    XCTAssertEqual(c.cS2RC("dkd"), "ㄎㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dii"), "ㄎㄞ")
+    XCTAssertEqual(c.cS2RC("dii"), "ㄎㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("diir"), "ㄎㄞˇ")
+    XCTAssertEqual(c.cS2RC("diir"), "ㄎㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("diid"), "ㄎㄞˋ")
+    XCTAssertEqual(c.cS2RC("diid"), "ㄎㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dl"), "ㄎㄠ")
+    XCTAssertEqual(c.cS2RC("dl"), "ㄎㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dlr"), "ㄎㄠˇ")
+    XCTAssertEqual(c.cS2RC("dlr"), "ㄎㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dld"), "ㄎㄠˋ")
+    XCTAssertEqual(c.cS2RC("dld"), "ㄎㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dm"), "ㄎㄡ")
+    XCTAssertEqual(c.cS2RC("dm"), "ㄎㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dmr"), "ㄎㄡˇ")
+    XCTAssertEqual(c.cS2RC("dmr"), "ㄎㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dmd"), "ㄎㄡˋ")
+    XCTAssertEqual(c.cS2RC("dmd"), "ㄎㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("doo"), "ㄎㄢ")
+    XCTAssertEqual(c.cS2RC("doo"), "ㄎㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("door"), "ㄎㄢˇ")
+    XCTAssertEqual(c.cS2RC("door"), "ㄎㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dood"), "ㄎㄢˋ")
+    XCTAssertEqual(c.cS2RC("dood"), "ㄎㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dp"), "ㄎㄣ")
+    XCTAssertEqual(c.cS2RC("dp"), "ㄎㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dpr"), "ㄎㄣˇ")
+    XCTAssertEqual(c.cS2RC("dpr"), "ㄎㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dpd"), "ㄎㄣˋ")
+    XCTAssertEqual(c.cS2RC("dpd"), "ㄎㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dll"), "ㄎㄤ")
+    XCTAssertEqual(c.cS2RC("dll"), "ㄎㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dlle"), "ㄎㄤˊ")
+    XCTAssertEqual(c.cS2RC("dlle"), "ㄎㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dllr"), "ㄎㄤˇ")
+    XCTAssertEqual(c.cS2RC("dllr"), "ㄎㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dlld"), "ㄎㄤˋ")
+    XCTAssertEqual(c.cS2RC("dlld"), "ㄎㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dn"), "ㄎㄥ")
+    XCTAssertEqual(c.cS2RC("dn"), "ㄎㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dnr"), "ㄎㄥˇ")
+    XCTAssertEqual(c.cS2RC("dnr"), "ㄎㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dj"), "ㄎㄨ")
+    XCTAssertEqual(c.cS2RC("dj"), "ㄎㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dje"), "ㄎㄨˊ")
+    XCTAssertEqual(c.cS2RC("dje"), "ㄎㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djr"), "ㄎㄨˇ")
+    XCTAssertEqual(c.cS2RC("djr"), "ㄎㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djd"), "ㄎㄨˋ")
+    XCTAssertEqual(c.cS2RC("djd"), "ㄎㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dju"), "ㄎㄨㄚ")
+    XCTAssertEqual(c.cS2RC("dju"), "ㄎㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djur"), "ㄎㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("djur"), "ㄎㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djud"), "ㄎㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("djud"), "ㄎㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djid"), "ㄎㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("djid"), "ㄎㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djii"), "ㄎㄨㄞ")
+    XCTAssertEqual(c.cS2RC("djii"), "ㄎㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djiir"), "ㄎㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("djiir"), "ㄎㄨㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djiid"), "ㄎㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("djiid"), "ㄎㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djo"), "ㄎㄨㄟ")
+    XCTAssertEqual(c.cS2RC("djo"), "ㄎㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djoe"), "ㄎㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("djoe"), "ㄎㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djor"), "ㄎㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("djor"), "ㄎㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djod"), "ㄎㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("djod"), "ㄎㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djoo"), "ㄎㄨㄢ")
+    XCTAssertEqual(c.cS2RC("djoo"), "ㄎㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djoor"), "ㄎㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("djoor"), "ㄎㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djood"), "ㄎㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("djood"), "ㄎㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djp"), "ㄎㄨㄣ")
+    XCTAssertEqual(c.cS2RC("djp"), "ㄎㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djpr"), "ㄎㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("djpr"), "ㄎㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djpd"), "ㄎㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("djpd"), "ㄎㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djll"), "ㄎㄨㄤ")
+    XCTAssertEqual(c.cS2RC("djll"), "ㄎㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djlle"), "ㄎㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("djlle"), "ㄎㄨㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djllr"), "ㄎㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("djllr"), "ㄎㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djlld"), "ㄎㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("djlld"), "ㄎㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djn"), "ㄎㄨㄥ")
+    XCTAssertEqual(c.cS2RC("djn"), "ㄎㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djnr"), "ㄎㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("djnr"), "ㄎㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("djnd"), "ㄎㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("djnd"), "ㄎㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuu"), "ㄏㄚ")
+    XCTAssertEqual(c.cS2RC("cuu"), "ㄏㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuue"), "ㄏㄚˊ")
+    XCTAssertEqual(c.cS2RC("cuue"), "ㄏㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuur"), "ㄏㄚˇ")
+    XCTAssertEqual(c.cS2RC("cuur"), "ㄏㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ck"), "ㄏㄜ")
+    XCTAssertEqual(c.cS2RC("ck"), "ㄏㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cke"), "ㄏㄜˊ")
+    XCTAssertEqual(c.cS2RC("cke"), "ㄏㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ckr"), "ㄏㄜˇ")
+    XCTAssertEqual(c.cS2RC("ckr"), "ㄏㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ckd"), "ㄏㄜˋ")
+    XCTAssertEqual(c.cS2RC("ckd"), "ㄏㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cii"), "ㄏㄞ")
+    XCTAssertEqual(c.cS2RC("cii"), "ㄏㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ciie"), "ㄏㄞˊ")
+    XCTAssertEqual(c.cS2RC("ciie"), "ㄏㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ciir"), "ㄏㄞˇ")
+    XCTAssertEqual(c.cS2RC("ciir"), "ㄏㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ciid"), "ㄏㄞˋ")
+    XCTAssertEqual(c.cS2RC("ciid"), "ㄏㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("co"), "ㄏㄟ")
+    XCTAssertEqual(c.cS2RC("co"), "ㄏㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cor"), "ㄏㄟˇ")
+    XCTAssertEqual(c.cS2RC("cor"), "ㄏㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cl"), "ㄏㄠ")
+    XCTAssertEqual(c.cS2RC("cl"), "ㄏㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cle"), "ㄏㄠˊ")
+    XCTAssertEqual(c.cS2RC("cle"), "ㄏㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("clr"), "ㄏㄠˇ")
+    XCTAssertEqual(c.cS2RC("clr"), "ㄏㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cld"), "ㄏㄠˋ")
+    XCTAssertEqual(c.cS2RC("cld"), "ㄏㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cm"), "ㄏㄡ")
+    XCTAssertEqual(c.cS2RC("cm"), "ㄏㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cme"), "ㄏㄡˊ")
+    XCTAssertEqual(c.cS2RC("cme"), "ㄏㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cmr"), "ㄏㄡˇ")
+    XCTAssertEqual(c.cS2RC("cmr"), "ㄏㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cmd"), "ㄏㄡˋ")
+    XCTAssertEqual(c.cS2RC("cmd"), "ㄏㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("coo"), "ㄏㄢ")
+    XCTAssertEqual(c.cS2RC("coo"), "ㄏㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cooe"), "ㄏㄢˊ")
+    XCTAssertEqual(c.cS2RC("cooe"), "ㄏㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("coor"), "ㄏㄢˇ")
+    XCTAssertEqual(c.cS2RC("coor"), "ㄏㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cood"), "ㄏㄢˋ")
+    XCTAssertEqual(c.cS2RC("cood"), "ㄏㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cp"), "ㄏㄣ")
+    XCTAssertEqual(c.cS2RC("cp"), "ㄏㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cpe"), "ㄏㄣˊ")
+    XCTAssertEqual(c.cS2RC("cpe"), "ㄏㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cpr"), "ㄏㄣˇ")
+    XCTAssertEqual(c.cS2RC("cpr"), "ㄏㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cpd"), "ㄏㄣˋ")
+    XCTAssertEqual(c.cS2RC("cpd"), "ㄏㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cll"), "ㄏㄤ")
+    XCTAssertEqual(c.cS2RC("cll"), "ㄏㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("clle"), "ㄏㄤˊ")
+    XCTAssertEqual(c.cS2RC("clle"), "ㄏㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cllr"), "ㄏㄤˇ")
+    XCTAssertEqual(c.cS2RC("cllr"), "ㄏㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("clld"), "ㄏㄤˋ")
+    XCTAssertEqual(c.cS2RC("clld"), "ㄏㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cn"), "ㄏㄥ")
+    XCTAssertEqual(c.cS2RC("cn"), "ㄏㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cne"), "ㄏㄥˊ")
+    XCTAssertEqual(c.cS2RC("cne"), "ㄏㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cnd"), "ㄏㄥˋ")
+    XCTAssertEqual(c.cS2RC("cnd"), "ㄏㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cj"), "ㄏㄨ")
+    XCTAssertEqual(c.cS2RC("cj"), "ㄏㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cje"), "ㄏㄨˊ")
+    XCTAssertEqual(c.cS2RC("cje"), "ㄏㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjr"), "ㄏㄨˇ")
+    XCTAssertEqual(c.cS2RC("cjr"), "ㄏㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjd"), "ㄏㄨˋ")
+    XCTAssertEqual(c.cS2RC("cjd"), "ㄏㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cju"), "ㄏㄨㄚ")
+    XCTAssertEqual(c.cS2RC("cju"), "ㄏㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjue"), "ㄏㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("cjue"), "ㄏㄨㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjur"), "ㄏㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("cjur"), "ㄏㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjud"), "ㄏㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("cjud"), "ㄏㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cji"), "ㄏㄨㄛ")
+    XCTAssertEqual(c.cS2RC("cji"), "ㄏㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjie"), "ㄏㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("cjie"), "ㄏㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjir"), "ㄏㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("cjir"), "ㄏㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjid"), "ㄏㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("cjid"), "ㄏㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjiy"), "ㄏㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("cjiy"), "ㄏㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjiie"), "ㄏㄨㄞˊ")
+    XCTAssertEqual(c.cS2RC("cjiie"), "ㄏㄨㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjiid"), "ㄏㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("cjiid"), "ㄏㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjo"), "ㄏㄨㄟ")
+    XCTAssertEqual(c.cS2RC("cjo"), "ㄏㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjoe"), "ㄏㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("cjoe"), "ㄏㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjor"), "ㄏㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("cjor"), "ㄏㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjod"), "ㄏㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("cjod"), "ㄏㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjoo"), "ㄏㄨㄢ")
+    XCTAssertEqual(c.cS2RC("cjoo"), "ㄏㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjooe"), "ㄏㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("cjooe"), "ㄏㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjoor"), "ㄏㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("cjoor"), "ㄏㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjood"), "ㄏㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("cjood"), "ㄏㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjp"), "ㄏㄨㄣ")
+    XCTAssertEqual(c.cS2RC("cjp"), "ㄏㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjpe"), "ㄏㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("cjpe"), "ㄏㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjpr"), "ㄏㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("cjpr"), "ㄏㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjpd"), "ㄏㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("cjpd"), "ㄏㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjll"), "ㄏㄨㄤ")
+    XCTAssertEqual(c.cS2RC("cjll"), "ㄏㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjlle"), "ㄏㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("cjlle"), "ㄏㄨㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjllr"), "ㄏㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("cjllr"), "ㄏㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjlld"), "ㄏㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("cjlld"), "ㄏㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjlly"), "ㄏㄨㄤ˙")
+    XCTAssertEqual(c.cS2RC("cjlly"), "ㄏㄨㄤ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjn"), "ㄏㄨㄥ")
+    XCTAssertEqual(c.cS2RC("cjn"), "ㄏㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjne"), "ㄏㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("cjne"), "ㄏㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjnr"), "ㄏㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("cjnr"), "ㄏㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cjnd"), "ㄏㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("cjnd"), "ㄏㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ru"), "ㄐㄧ")
+    XCTAssertEqual(c.cS2RC("ru"), "ㄐㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rue"), "ㄐㄧˊ")
+    XCTAssertEqual(c.cS2RC("rue"), "ㄐㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rur"), "ㄐㄧˇ")
+    XCTAssertEqual(c.cS2RC("rur"), "ㄐㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rud"), "ㄐㄧˋ")
+    XCTAssertEqual(c.cS2RC("rud"), "ㄐㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruuu"), "ㄐㄧㄚ")
+    XCTAssertEqual(c.cS2RC("ruuu"), "ㄐㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruuue"), "ㄐㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("ruuue"), "ㄐㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruuur"), "ㄐㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("ruuur"), "ㄐㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruuud"), "ㄐㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("ruuud"), "ㄐㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rub"), "ㄐㄧㄝ")
+    XCTAssertEqual(c.cS2RC("rub"), "ㄐㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rube"), "ㄐㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("rube"), "ㄐㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rubr"), "ㄐㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("rubr"), "ㄐㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rubd"), "ㄐㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("rubd"), "ㄐㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruby"), "ㄐㄧㄝ˙")
+    XCTAssertEqual(c.cS2RC("ruby"), "ㄐㄧㄝ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rul"), "ㄐㄧㄠ")
+    XCTAssertEqual(c.cS2RC("rul"), "ㄐㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rule"), "ㄐㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("rule"), "ㄐㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rulr"), "ㄐㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("rulr"), "ㄐㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruld"), "ㄐㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("ruld"), "ㄐㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rum"), "ㄐㄧㄡ")
+    XCTAssertEqual(c.cS2RC("rum"), "ㄐㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rumr"), "ㄐㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("rumr"), "ㄐㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rumd"), "ㄐㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("rumd"), "ㄐㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruoo"), "ㄐㄧㄢ")
+    XCTAssertEqual(c.cS2RC("ruoo"), "ㄐㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruoor"), "ㄐㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("ruoor"), "ㄐㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ruood"), "ㄐㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("ruood"), "ㄐㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rup"), "ㄐㄧㄣ")
+    XCTAssertEqual(c.cS2RC("rup"), "ㄐㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rupr"), "ㄐㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("rupr"), "ㄐㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rupd"), "ㄐㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("rupd"), "ㄐㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rull"), "ㄐㄧㄤ")
+    XCTAssertEqual(c.cS2RC("rull"), "ㄐㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rulle"), "ㄐㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("rulle"), "ㄐㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rullr"), "ㄐㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("rullr"), "ㄐㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rulld"), "ㄐㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("rulld"), "ㄐㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("run"), "ㄐㄧㄥ")
+    XCTAssertEqual(c.cS2RC("run"), "ㄐㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("runr"), "ㄐㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("runr"), "ㄐㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rund"), "ㄐㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("rund"), "ㄐㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rm"), "ㄐㄩ")
+    XCTAssertEqual(c.cS2RC("rm"), "ㄐㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rme"), "ㄐㄩˊ")
+    XCTAssertEqual(c.cS2RC("rme"), "ㄐㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmr"), "ㄐㄩˇ")
+    XCTAssertEqual(c.cS2RC("rmr"), "ㄐㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmd"), "ㄐㄩˋ")
+    XCTAssertEqual(c.cS2RC("rmd"), "ㄐㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmb"), "ㄐㄩㄝ")
+    XCTAssertEqual(c.cS2RC("rmb"), "ㄐㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmbe"), "ㄐㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("rmbe"), "ㄐㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmbr"), "ㄐㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("rmbr"), "ㄐㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmbd"), "ㄐㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("rmbd"), "ㄐㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmoo"), "ㄐㄩㄢ")
+    XCTAssertEqual(c.cS2RC("rmoo"), "ㄐㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmoor"), "ㄐㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("rmoor"), "ㄐㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmood"), "ㄐㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("rmood"), "ㄐㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmp"), "ㄐㄩㄣ")
+    XCTAssertEqual(c.cS2RC("rmp"), "ㄐㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmpe"), "ㄐㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("rmpe"), "ㄐㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmpr"), "ㄐㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("rmpr"), "ㄐㄩㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmpd"), "ㄐㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("rmpd"), "ㄐㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmn"), "ㄐㄩㄥ")
+    XCTAssertEqual(c.cS2RC("rmn"), "ㄐㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmnr"), "ㄐㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("rmnr"), "ㄐㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("rmnd"), "ㄐㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("rmnd"), "ㄐㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fy"), "ㄑ˙")
+    XCTAssertEqual(c.cS2RC("fy"), "ㄑ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fu"), "ㄑㄧ")
+    XCTAssertEqual(c.cS2RC("fu"), "ㄑㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fue"), "ㄑㄧˊ")
+    XCTAssertEqual(c.cS2RC("fue"), "ㄑㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fur"), "ㄑㄧˇ")
+    XCTAssertEqual(c.cS2RC("fur"), "ㄑㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fud"), "ㄑㄧˋ")
+    XCTAssertEqual(c.cS2RC("fud"), "ㄑㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuuu"), "ㄑㄧㄚ")
+    XCTAssertEqual(c.cS2RC("fuuu"), "ㄑㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuuue"), "ㄑㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("fuuue"), "ㄑㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuuur"), "ㄑㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("fuuur"), "ㄑㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuuud"), "ㄑㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("fuuud"), "ㄑㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fub"), "ㄑㄧㄝ")
+    XCTAssertEqual(c.cS2RC("fub"), "ㄑㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fube"), "ㄑㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("fube"), "ㄑㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fubr"), "ㄑㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("fubr"), "ㄑㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fubd"), "ㄑㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("fubd"), "ㄑㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ful"), "ㄑㄧㄠ")
+    XCTAssertEqual(c.cS2RC("ful"), "ㄑㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fule"), "ㄑㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("fule"), "ㄑㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fulr"), "ㄑㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("fulr"), "ㄑㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuld"), "ㄑㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("fuld"), "ㄑㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fum"), "ㄑㄧㄡ")
+    XCTAssertEqual(c.cS2RC("fum"), "ㄑㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fume"), "ㄑㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("fume"), "ㄑㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fumr"), "ㄑㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("fumr"), "ㄑㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fumd"), "ㄑㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("fumd"), "ㄑㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuoo"), "ㄑㄧㄢ")
+    XCTAssertEqual(c.cS2RC("fuoo"), "ㄑㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuooe"), "ㄑㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("fuooe"), "ㄑㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuoor"), "ㄑㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("fuoor"), "ㄑㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fuood"), "ㄑㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("fuood"), "ㄑㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fup"), "ㄑㄧㄣ")
+    XCTAssertEqual(c.cS2RC("fup"), "ㄑㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fupe"), "ㄑㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("fupe"), "ㄑㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fupr"), "ㄑㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("fupr"), "ㄑㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fupd"), "ㄑㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("fupd"), "ㄑㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("full"), "ㄑㄧㄤ")
+    XCTAssertEqual(c.cS2RC("full"), "ㄑㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fulle"), "ㄑㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("fulle"), "ㄑㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fullr"), "ㄑㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("fullr"), "ㄑㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fulld"), "ㄑㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("fulld"), "ㄑㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fun"), "ㄑㄧㄥ")
+    XCTAssertEqual(c.cS2RC("fun"), "ㄑㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fune"), "ㄑㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("fune"), "ㄑㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("funr"), "ㄑㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("funr"), "ㄑㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fund"), "ㄑㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("fund"), "ㄑㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fm"), "ㄑㄩ")
+    XCTAssertEqual(c.cS2RC("fm"), "ㄑㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fme"), "ㄑㄩˊ")
+    XCTAssertEqual(c.cS2RC("fme"), "ㄑㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmr"), "ㄑㄩˇ")
+    XCTAssertEqual(c.cS2RC("fmr"), "ㄑㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmd"), "ㄑㄩˋ")
+    XCTAssertEqual(c.cS2RC("fmd"), "ㄑㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmb"), "ㄑㄩㄝ")
+    XCTAssertEqual(c.cS2RC("fmb"), "ㄑㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmbe"), "ㄑㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("fmbe"), "ㄑㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmbd"), "ㄑㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("fmbd"), "ㄑㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmoo"), "ㄑㄩㄢ")
+    XCTAssertEqual(c.cS2RC("fmoo"), "ㄑㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmooe"), "ㄑㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("fmooe"), "ㄑㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmoor"), "ㄑㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("fmoor"), "ㄑㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmood"), "ㄑㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("fmood"), "ㄑㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmp"), "ㄑㄩㄣ")
+    XCTAssertEqual(c.cS2RC("fmp"), "ㄑㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmpe"), "ㄑㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("fmpe"), "ㄑㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmpr"), "ㄑㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("fmpr"), "ㄑㄩㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmpd"), "ㄑㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("fmpd"), "ㄑㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmn"), "ㄑㄩㄥ")
+    XCTAssertEqual(c.cS2RC("fmn"), "ㄑㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmne"), "ㄑㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("fmne"), "ㄑㄩㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmnr"), "ㄑㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("fmnr"), "ㄑㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmnd"), "ㄑㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("fmnd"), "ㄑㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vu"), "ㄒㄧ")
+    XCTAssertEqual(c.cS2RC("vu"), "ㄒㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vue"), "ㄒㄧˊ")
+    XCTAssertEqual(c.cS2RC("vue"), "ㄒㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vur"), "ㄒㄧˇ")
+    XCTAssertEqual(c.cS2RC("vur"), "ㄒㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vud"), "ㄒㄧˋ")
+    XCTAssertEqual(c.cS2RC("vud"), "ㄒㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuuu"), "ㄒㄧㄚ")
+    XCTAssertEqual(c.cS2RC("vuuu"), "ㄒㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuuue"), "ㄒㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("vuuue"), "ㄒㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuuur"), "ㄒㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("vuuur"), "ㄒㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuuud"), "ㄒㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("vuuud"), "ㄒㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vub"), "ㄒㄧㄝ")
+    XCTAssertEqual(c.cS2RC("vub"), "ㄒㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vube"), "ㄒㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("vube"), "ㄒㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vubr"), "ㄒㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("vubr"), "ㄒㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vubd"), "ㄒㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("vubd"), "ㄒㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vul"), "ㄒㄧㄠ")
+    XCTAssertEqual(c.cS2RC("vul"), "ㄒㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vule"), "ㄒㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("vule"), "ㄒㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vulr"), "ㄒㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("vulr"), "ㄒㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuld"), "ㄒㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("vuld"), "ㄒㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vum"), "ㄒㄧㄡ")
+    XCTAssertEqual(c.cS2RC("vum"), "ㄒㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vume"), "ㄒㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("vume"), "ㄒㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vumr"), "ㄒㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("vumr"), "ㄒㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vumd"), "ㄒㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("vumd"), "ㄒㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuoo"), "ㄒㄧㄢ")
+    XCTAssertEqual(c.cS2RC("vuoo"), "ㄒㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuooe"), "ㄒㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("vuooe"), "ㄒㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuoor"), "ㄒㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("vuoor"), "ㄒㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuood"), "ㄒㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("vuood"), "ㄒㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vup"), "ㄒㄧㄣ")
+    XCTAssertEqual(c.cS2RC("vup"), "ㄒㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vupe"), "ㄒㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("vupe"), "ㄒㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vupr"), "ㄒㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("vupr"), "ㄒㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vupd"), "ㄒㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("vupd"), "ㄒㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vull"), "ㄒㄧㄤ")
+    XCTAssertEqual(c.cS2RC("vull"), "ㄒㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vulle"), "ㄒㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("vulle"), "ㄒㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vullr"), "ㄒㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("vullr"), "ㄒㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vulld"), "ㄒㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("vulld"), "ㄒㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vun"), "ㄒㄧㄥ")
+    XCTAssertEqual(c.cS2RC("vun"), "ㄒㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vune"), "ㄒㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("vune"), "ㄒㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vunr"), "ㄒㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("vunr"), "ㄒㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vund"), "ㄒㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("vund"), "ㄒㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vm"), "ㄒㄩ")
+    XCTAssertEqual(c.cS2RC("vm"), "ㄒㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vme"), "ㄒㄩˊ")
+    XCTAssertEqual(c.cS2RC("vme"), "ㄒㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmr"), "ㄒㄩˇ")
+    XCTAssertEqual(c.cS2RC("vmr"), "ㄒㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmd"), "ㄒㄩˋ")
+    XCTAssertEqual(c.cS2RC("vmd"), "ㄒㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmb"), "ㄒㄩㄝ")
+    XCTAssertEqual(c.cS2RC("vmb"), "ㄒㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmbe"), "ㄒㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("vmbe"), "ㄒㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmbr"), "ㄒㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("vmbr"), "ㄒㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmbd"), "ㄒㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("vmbd"), "ㄒㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmoo"), "ㄒㄩㄢ")
+    XCTAssertEqual(c.cS2RC("vmoo"), "ㄒㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmooe"), "ㄒㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("vmooe"), "ㄒㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmoor"), "ㄒㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("vmoor"), "ㄒㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmood"), "ㄒㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("vmood"), "ㄒㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmp"), "ㄒㄩㄣ")
+    XCTAssertEqual(c.cS2RC("vmp"), "ㄒㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmpe"), "ㄒㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("vmpe"), "ㄒㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmpd"), "ㄒㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("vmpd"), "ㄒㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmn"), "ㄒㄩㄥ")
+    XCTAssertEqual(c.cS2RC("vmn"), "ㄒㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmne"), "ㄒㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("vmne"), "ㄒㄩㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmnr"), "ㄒㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("vmnr"), "ㄒㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmnd"), "ㄒㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("vmnd"), "ㄒㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tt"), "ㄓ")
+    XCTAssertEqual(c.cS2RC("tt"), "ㄓ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tte"), "ㄓˊ")
+    XCTAssertEqual(c.cS2RC("tte"), "ㄓˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttr"), "ㄓˇ")
+    XCTAssertEqual(c.cS2RC("ttr"), "ㄓˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttd"), "ㄓˋ")
+    XCTAssertEqual(c.cS2RC("ttd"), "ㄓˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttuu"), "ㄓㄚ")
+    XCTAssertEqual(c.cS2RC("ttuu"), "ㄓㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttuue"), "ㄓㄚˊ")
+    XCTAssertEqual(c.cS2RC("ttuue"), "ㄓㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttuur"), "ㄓㄚˇ")
+    XCTAssertEqual(c.cS2RC("ttuur"), "ㄓㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttuud"), "ㄓㄚˋ")
+    XCTAssertEqual(c.cS2RC("ttuud"), "ㄓㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttk"), "ㄓㄜ")
+    XCTAssertEqual(c.cS2RC("ttk"), "ㄓㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttke"), "ㄓㄜˊ")
+    XCTAssertEqual(c.cS2RC("ttke"), "ㄓㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttkr"), "ㄓㄜˇ")
+    XCTAssertEqual(c.cS2RC("ttkr"), "ㄓㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttkd"), "ㄓㄜˋ")
+    XCTAssertEqual(c.cS2RC("ttkd"), "ㄓㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttky"), "ㄓㄜ˙")
+    XCTAssertEqual(c.cS2RC("ttky"), "ㄓㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttii"), "ㄓㄞ")
+    XCTAssertEqual(c.cS2RC("ttii"), "ㄓㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttiie"), "ㄓㄞˊ")
+    XCTAssertEqual(c.cS2RC("ttiie"), "ㄓㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttiir"), "ㄓㄞˇ")
+    XCTAssertEqual(c.cS2RC("ttiir"), "ㄓㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttiid"), "ㄓㄞˋ")
+    XCTAssertEqual(c.cS2RC("ttiid"), "ㄓㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttod"), "ㄓㄟˋ")
+    XCTAssertEqual(c.cS2RC("ttod"), "ㄓㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttl"), "ㄓㄠ")
+    XCTAssertEqual(c.cS2RC("ttl"), "ㄓㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttle"), "ㄓㄠˊ")
+    XCTAssertEqual(c.cS2RC("ttle"), "ㄓㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttlr"), "ㄓㄠˇ")
+    XCTAssertEqual(c.cS2RC("ttlr"), "ㄓㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttld"), "ㄓㄠˋ")
+    XCTAssertEqual(c.cS2RC("ttld"), "ㄓㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttm"), "ㄓㄡ")
+    XCTAssertEqual(c.cS2RC("ttm"), "ㄓㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttme"), "ㄓㄡˊ")
+    XCTAssertEqual(c.cS2RC("ttme"), "ㄓㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttmr"), "ㄓㄡˇ")
+    XCTAssertEqual(c.cS2RC("ttmr"), "ㄓㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttmd"), "ㄓㄡˋ")
+    XCTAssertEqual(c.cS2RC("ttmd"), "ㄓㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttoo"), "ㄓㄢ")
+    XCTAssertEqual(c.cS2RC("ttoo"), "ㄓㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttoor"), "ㄓㄢˇ")
+    XCTAssertEqual(c.cS2RC("ttoor"), "ㄓㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttood"), "ㄓㄢˋ")
+    XCTAssertEqual(c.cS2RC("ttood"), "ㄓㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttp"), "ㄓㄣ")
+    XCTAssertEqual(c.cS2RC("ttp"), "ㄓㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttpe"), "ㄓㄣˊ")
+    XCTAssertEqual(c.cS2RC("ttpe"), "ㄓㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttpr"), "ㄓㄣˇ")
+    XCTAssertEqual(c.cS2RC("ttpr"), "ㄓㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttpd"), "ㄓㄣˋ")
+    XCTAssertEqual(c.cS2RC("ttpd"), "ㄓㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttll"), "ㄓㄤ")
+    XCTAssertEqual(c.cS2RC("ttll"), "ㄓㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttllr"), "ㄓㄤˇ")
+    XCTAssertEqual(c.cS2RC("ttllr"), "ㄓㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttlld"), "ㄓㄤˋ")
+    XCTAssertEqual(c.cS2RC("ttlld"), "ㄓㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttn"), "ㄓㄥ")
+    XCTAssertEqual(c.cS2RC("ttn"), "ㄓㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttnr"), "ㄓㄥˇ")
+    XCTAssertEqual(c.cS2RC("ttnr"), "ㄓㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttnd"), "ㄓㄥˋ")
+    XCTAssertEqual(c.cS2RC("ttnd"), "ㄓㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttj"), "ㄓㄨ")
+    XCTAssertEqual(c.cS2RC("ttj"), "ㄓㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttje"), "ㄓㄨˊ")
+    XCTAssertEqual(c.cS2RC("ttje"), "ㄓㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttjr"), "ㄓㄨˇ")
+    XCTAssertEqual(c.cS2RC("ttjr"), "ㄓㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttjd"), "ㄓㄨˋ")
+    XCTAssertEqual(c.cS2RC("ttjd"), "ㄓㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttju"), "ㄓㄨㄚ")
+    XCTAssertEqual(c.cS2RC("ttju"), "ㄓㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttjur"), "ㄓㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("ttjur"), "ㄓㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttji"), "ㄓㄨㄛ")
+    XCTAssertEqual(c.cS2RC("ttji"), "ㄓㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttjie"), "ㄓㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("ttjie"), "ㄓㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttjid"), "ㄓㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("ttjid"), "ㄓㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttjii"), "ㄓㄨㄞ")
+    XCTAssertEqual(c.cS2RC("ttjii"), "ㄓㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttjiir"), "ㄓㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("ttjiir"), "ㄓㄨㄞˇ")
   }
 }

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_A.swift

@@ -11,492 +11,496 @@ import XCTest
 @testable import Tekkon
 
 extension TekkonTestsKeyboardArrangments {
+  func testETen26KeysTaigi() throws {
+    var c = Tekkon.Composer(arrange: .ofETen26)
+    XCTAssertEqual(c.cS2RC("ket"), "ㄎㄧㄤ")
+    // XCTAssertEqual(c.cS2RC("vezf"), "ㄍㄧㄠˊ")
+    // XCTAssertEqual(c.cS2RC("ven"), "ㄍㄧㄣ")
+  }
+
   func testETen26KeysA() throws {
-    var composer = Tekkon.Composer(arrange: .ofETen26)
+    var c = Tekkon.Composer(arrange: .ofETen26)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ket"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("betf"), "ㄅㄧㄤˊ")
-    // XCTAssertEqual(composer.convertSequenceToRawComposition("vezf"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("betk"), "ㄅㄧㄤˋ")
-    // XCTAssertEqual(composer.convertSequenceToRawComposition("ven"), "ㄍㄧㄣ")
+    XCTAssertEqual(c.cS2RC("dxt"), "ㄉㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("betf"), "ㄅㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("ba"), "ㄅㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("betk"), "ㄅㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("baf"), "ㄅㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxt"), "ㄉㄨㄤ")
+    XCTAssertEqual(c.cS2RC("baj"), "ㄅㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ba"), "ㄅㄚ")
+    XCTAssertEqual(c.cS2RC("bak"), "ㄅㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("baf"), "ㄅㄚˊ")
+    XCTAssertEqual(c.cS2RC("bad"), "ㄅㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("baj"), "ㄅㄚˇ")
+    XCTAssertEqual(c.cS2RC("bo"), "ㄅㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bak"), "ㄅㄚˋ")
+    XCTAssertEqual(c.cS2RC("bof"), "ㄅㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bad"), "ㄅㄚ˙")
+    XCTAssertEqual(c.cS2RC("boj"), "ㄅㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bo"), "ㄅㄛ")
+    XCTAssertEqual(c.cS2RC("bok"), "ㄅㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bof"), "ㄅㄛˊ")
+    XCTAssertEqual(c.cS2RC("bod"), "ㄅㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("boj"), "ㄅㄛˇ")
+    XCTAssertEqual(c.cS2RC("bi"), "ㄅㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bok"), "ㄅㄛˋ")
+    XCTAssertEqual(c.cS2RC("bif"), "ㄅㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bod"), "ㄅㄛ˙")
+    XCTAssertEqual(c.cS2RC("bij"), "ㄅㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bi"), "ㄅㄞ")
+    XCTAssertEqual(c.cS2RC("bik"), "ㄅㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bif"), "ㄅㄞˊ")
+    XCTAssertEqual(c.cS2RC("bid"), "ㄅㄞ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bij"), "ㄅㄞˇ")
+    XCTAssertEqual(c.cS2RC("bq"), "ㄅㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bik"), "ㄅㄞˋ")
+    XCTAssertEqual(c.cS2RC("bqj"), "ㄅㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bid"), "ㄅㄞ˙")
+    XCTAssertEqual(c.cS2RC("bqk"), "ㄅㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bq"), "ㄅㄟ")
+    XCTAssertEqual(c.cS2RC("bqd"), "ㄅㄟ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bqj"), "ㄅㄟˇ")
+    XCTAssertEqual(c.cS2RC("bz"), "ㄅㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bqk"), "ㄅㄟˋ")
+    XCTAssertEqual(c.cS2RC("bzf"), "ㄅㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bqd"), "ㄅㄟ˙")
+    XCTAssertEqual(c.cS2RC("bzj"), "ㄅㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bz"), "ㄅㄠ")
+    XCTAssertEqual(c.cS2RC("bzk"), "ㄅㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bzf"), "ㄅㄠˊ")
+    XCTAssertEqual(c.cS2RC("bm"), "ㄅㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bzj"), "ㄅㄠˇ")
+    XCTAssertEqual(c.cS2RC("bmj"), "ㄅㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bzk"), "ㄅㄠˋ")
+    XCTAssertEqual(c.cS2RC("bmk"), "ㄅㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bm"), "ㄅㄢ")
+    XCTAssertEqual(c.cS2RC("bn"), "ㄅㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bmj"), "ㄅㄢˇ")
+    XCTAssertEqual(c.cS2RC("bnj"), "ㄅㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bmk"), "ㄅㄢˋ")
+    XCTAssertEqual(c.cS2RC("bnk"), "ㄅㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bn"), "ㄅㄣ")
+    XCTAssertEqual(c.cS2RC("bt"), "ㄅㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bnj"), "ㄅㄣˇ")
+    XCTAssertEqual(c.cS2RC("btj"), "ㄅㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bnk"), "ㄅㄣˋ")
+    XCTAssertEqual(c.cS2RC("btk"), "ㄅㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bt"), "ㄅㄤ")
+    XCTAssertEqual(c.cS2RC("bl"), "ㄅㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("btj"), "ㄅㄤˇ")
+    XCTAssertEqual(c.cS2RC("blf"), "ㄅㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("btk"), "ㄅㄤˋ")
+    XCTAssertEqual(c.cS2RC("blj"), "ㄅㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bl"), "ㄅㄥ")
+    XCTAssertEqual(c.cS2RC("blk"), "ㄅㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("blf"), "ㄅㄥˊ")
+    XCTAssertEqual(c.cS2RC("be"), "ㄅㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("blj"), "ㄅㄥˇ")
+    XCTAssertEqual(c.cS2RC("bef"), "ㄅㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("blk"), "ㄅㄥˋ")
+    XCTAssertEqual(c.cS2RC("bej"), "ㄅㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("be"), "ㄅㄧ")
+    XCTAssertEqual(c.cS2RC("bek"), "ㄅㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bef"), "ㄅㄧˊ")
+    XCTAssertEqual(c.cS2RC("bew"), "ㄅㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bej"), "ㄅㄧˇ")
+    XCTAssertEqual(c.cS2RC("bewf"), "ㄅㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bek"), "ㄅㄧˋ")
+    XCTAssertEqual(c.cS2RC("bewj"), "ㄅㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bew"), "ㄅㄧㄝ")
+    XCTAssertEqual(c.cS2RC("bewk"), "ㄅㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bewf"), "ㄅㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("bez"), "ㄅㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bewj"), "ㄅㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("bezj"), "ㄅㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bewk"), "ㄅㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("bezk"), "ㄅㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bez"), "ㄅㄧㄠ")
+    XCTAssertEqual(c.cS2RC("bem"), "ㄅㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bezj"), "ㄅㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("bemf"), "ㄅㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bezk"), "ㄅㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("bemj"), "ㄅㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bem"), "ㄅㄧㄢ")
+    XCTAssertEqual(c.cS2RC("bemk"), "ㄅㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bemf"), "ㄅㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("ben"), "ㄅㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bemj"), "ㄅㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("benj"), "ㄅㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bemk"), "ㄅㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("benk"), "ㄅㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ben"), "ㄅㄧㄣ")
+    XCTAssertEqual(c.cS2RC("bel"), "ㄅㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("benj"), "ㄅㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("belj"), "ㄅㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("benk"), "ㄅㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("belk"), "ㄅㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bel"), "ㄅㄧㄥ")
+    XCTAssertEqual(c.cS2RC("bx"), "ㄅㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("belj"), "ㄅㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("bxf"), "ㄅㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("belk"), "ㄅㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("bxj"), "ㄅㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bx"), "ㄅㄨ")
+    XCTAssertEqual(c.cS2RC("bxk"), "ㄅㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bxf"), "ㄅㄨˊ")
+    XCTAssertEqual(c.cS2RC("pa"), "ㄆㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bxj"), "ㄅㄨˇ")
+    XCTAssertEqual(c.cS2RC("paf"), "ㄆㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bxk"), "ㄅㄨˋ")
+    XCTAssertEqual(c.cS2RC("paj"), "ㄆㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pa"), "ㄆㄚ")
+    XCTAssertEqual(c.cS2RC("pak"), "ㄆㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("paf"), "ㄆㄚˊ")
+    XCTAssertEqual(c.cS2RC("pad"), "ㄆㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("paj"), "ㄆㄚˇ")
+    XCTAssertEqual(c.cS2RC("po"), "ㄆㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pak"), "ㄆㄚˋ")
+    XCTAssertEqual(c.cS2RC("pof"), "ㄆㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pad"), "ㄆㄚ˙")
+    XCTAssertEqual(c.cS2RC("poj"), "ㄆㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("po"), "ㄆㄛ")
+    XCTAssertEqual(c.cS2RC("pok"), "ㄆㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pof"), "ㄆㄛˊ")
+    XCTAssertEqual(c.cS2RC("pi"), "ㄆㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("poj"), "ㄆㄛˇ")
+    XCTAssertEqual(c.cS2RC("pif"), "ㄆㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pok"), "ㄆㄛˋ")
+    XCTAssertEqual(c.cS2RC("pij"), "ㄆㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pi"), "ㄆㄞ")
+    XCTAssertEqual(c.cS2RC("pik"), "ㄆㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pif"), "ㄆㄞˊ")
+    XCTAssertEqual(c.cS2RC("pq"), "ㄆㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pij"), "ㄆㄞˇ")
+    XCTAssertEqual(c.cS2RC("pqf"), "ㄆㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pik"), "ㄆㄞˋ")
+    XCTAssertEqual(c.cS2RC("pqj"), "ㄆㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pq"), "ㄆㄟ")
+    XCTAssertEqual(c.cS2RC("pqk"), "ㄆㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pqf"), "ㄆㄟˊ")
+    XCTAssertEqual(c.cS2RC("pz"), "ㄆㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pqj"), "ㄆㄟˇ")
+    XCTAssertEqual(c.cS2RC("pzf"), "ㄆㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pqk"), "ㄆㄟˋ")
+    XCTAssertEqual(c.cS2RC("pzj"), "ㄆㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pz"), "ㄆㄠ")
+    XCTAssertEqual(c.cS2RC("pzk"), "ㄆㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pzf"), "ㄆㄠˊ")
+    XCTAssertEqual(c.cS2RC("pp"), "ㄆㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pzj"), "ㄆㄠˇ")
+    XCTAssertEqual(c.cS2RC("ppf"), "ㄆㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pzk"), "ㄆㄠˋ")
+    XCTAssertEqual(c.cS2RC("ppj"), "ㄆㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pp"), "ㄆㄡ")
+    XCTAssertEqual(c.cS2RC("ppk"), "ㄆㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ppf"), "ㄆㄡˊ")
+    XCTAssertEqual(c.cS2RC("pm"), "ㄆㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ppj"), "ㄆㄡˇ")
+    XCTAssertEqual(c.cS2RC("pmf"), "ㄆㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ppk"), "ㄆㄡˋ")
+    XCTAssertEqual(c.cS2RC("pmj"), "ㄆㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pm"), "ㄆㄢ")
+    XCTAssertEqual(c.cS2RC("pmk"), "ㄆㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pmf"), "ㄆㄢˊ")
+    XCTAssertEqual(c.cS2RC("pn"), "ㄆㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pmj"), "ㄆㄢˇ")
+    XCTAssertEqual(c.cS2RC("pnf"), "ㄆㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pmk"), "ㄆㄢˋ")
+    XCTAssertEqual(c.cS2RC("pnj"), "ㄆㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pn"), "ㄆㄣ")
+    XCTAssertEqual(c.cS2RC("pnk"), "ㄆㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pnf"), "ㄆㄣˊ")
+    XCTAssertEqual(c.cS2RC("pt"), "ㄆㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pnj"), "ㄆㄣˇ")
+    XCTAssertEqual(c.cS2RC("ptf"), "ㄆㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pnk"), "ㄆㄣˋ")
+    XCTAssertEqual(c.cS2RC("ptj"), "ㄆㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pt"), "ㄆㄤ")
+    XCTAssertEqual(c.cS2RC("ptk"), "ㄆㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ptf"), "ㄆㄤˊ")
+    XCTAssertEqual(c.cS2RC("pl"), "ㄆㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ptj"), "ㄆㄤˇ")
+    XCTAssertEqual(c.cS2RC("plf"), "ㄆㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ptk"), "ㄆㄤˋ")
+    XCTAssertEqual(c.cS2RC("plj"), "ㄆㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pl"), "ㄆㄥ")
+    XCTAssertEqual(c.cS2RC("plk"), "ㄆㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("plf"), "ㄆㄥˊ")
+    XCTAssertEqual(c.cS2RC("pe"), "ㄆㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("plj"), "ㄆㄥˇ")
+    XCTAssertEqual(c.cS2RC("pef"), "ㄆㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("plk"), "ㄆㄥˋ")
+    XCTAssertEqual(c.cS2RC("pej"), "ㄆㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pe"), "ㄆㄧ")
+    XCTAssertEqual(c.cS2RC("pek"), "ㄆㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pef"), "ㄆㄧˊ")
+    XCTAssertEqual(c.cS2RC("pea"), "ㄆㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pej"), "ㄆㄧˇ")
+    XCTAssertEqual(c.cS2RC("pew"), "ㄆㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pek"), "ㄆㄧˋ")
+    XCTAssertEqual(c.cS2RC("pewj"), "ㄆㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pea"), "ㄆㄧㄚ")
+    XCTAssertEqual(c.cS2RC("pewk"), "ㄆㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pew"), "ㄆㄧㄝ")
+    XCTAssertEqual(c.cS2RC("pez"), "ㄆㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pewj"), "ㄆㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("pezf"), "ㄆㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pewk"), "ㄆㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("pezj"), "ㄆㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pez"), "ㄆㄧㄠ")
+    XCTAssertEqual(c.cS2RC("pezk"), "ㄆㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pezf"), "ㄆㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("pem"), "ㄆㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pezj"), "ㄆㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("pemf"), "ㄆㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pezk"), "ㄆㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("pemj"), "ㄆㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pem"), "ㄆㄧㄢ")
+    XCTAssertEqual(c.cS2RC("pemk"), "ㄆㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pemf"), "ㄆㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("pen"), "ㄆㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pemj"), "ㄆㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("penf"), "ㄆㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pemk"), "ㄆㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("penj"), "ㄆㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pen"), "ㄆㄧㄣ")
+    XCTAssertEqual(c.cS2RC("penk"), "ㄆㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("penf"), "ㄆㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("pel"), "ㄆㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("penj"), "ㄆㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("pelf"), "ㄆㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("penk"), "ㄆㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("pelj"), "ㄆㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pel"), "ㄆㄧㄥ")
+    XCTAssertEqual(c.cS2RC("pelk"), "ㄆㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pelf"), "ㄆㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("px"), "ㄆㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pelj"), "ㄆㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("pxf"), "ㄆㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pelk"), "ㄆㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("pxj"), "ㄆㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("px"), "ㄆㄨ")
+    XCTAssertEqual(c.cS2RC("pxk"), "ㄆㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pxf"), "ㄆㄨˊ")
+    XCTAssertEqual(c.cS2RC("ma"), "ㄇㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pxj"), "ㄆㄨˇ")
+    XCTAssertEqual(c.cS2RC("maf"), "ㄇㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pxk"), "ㄆㄨˋ")
+    XCTAssertEqual(c.cS2RC("maj"), "ㄇㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ma"), "ㄇㄚ")
+    XCTAssertEqual(c.cS2RC("mak"), "ㄇㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("maf"), "ㄇㄚˊ")
+    XCTAssertEqual(c.cS2RC("mad"), "ㄇㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("maj"), "ㄇㄚˇ")
+    XCTAssertEqual(c.cS2RC("mo"), "ㄇㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mak"), "ㄇㄚˋ")
+    XCTAssertEqual(c.cS2RC("mof"), "ㄇㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mad"), "ㄇㄚ˙")
+    XCTAssertEqual(c.cS2RC("moj"), "ㄇㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mo"), "ㄇㄛ")
+    XCTAssertEqual(c.cS2RC("mok"), "ㄇㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mof"), "ㄇㄛˊ")
+    XCTAssertEqual(c.cS2RC("mod"), "ㄇㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("moj"), "ㄇㄛˇ")
+    XCTAssertEqual(c.cS2RC("mr"), "ㄇㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mok"), "ㄇㄛˋ")
+    XCTAssertEqual(c.cS2RC("mrk"), "ㄇㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mod"), "ㄇㄛ˙")
+    XCTAssertEqual(c.cS2RC("mrd"), "ㄇㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mr"), "ㄇㄜ")
+    XCTAssertEqual(c.cS2RC("mi"), "ㄇㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mrk"), "ㄇㄜˋ")
+    XCTAssertEqual(c.cS2RC("mif"), "ㄇㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mrd"), "ㄇㄜ˙")
+    XCTAssertEqual(c.cS2RC("mij"), "ㄇㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mi"), "ㄇㄞ")
+    XCTAssertEqual(c.cS2RC("mik"), "ㄇㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mif"), "ㄇㄞˊ")
+    XCTAssertEqual(c.cS2RC("mqf"), "ㄇㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mij"), "ㄇㄞˇ")
+    XCTAssertEqual(c.cS2RC("mqj"), "ㄇㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mik"), "ㄇㄞˋ")
+    XCTAssertEqual(c.cS2RC("mqk"), "ㄇㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mqf"), "ㄇㄟˊ")
+    XCTAssertEqual(c.cS2RC("mz"), "ㄇㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mqj"), "ㄇㄟˇ")
+    XCTAssertEqual(c.cS2RC("mzf"), "ㄇㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mqk"), "ㄇㄟˋ")
+    XCTAssertEqual(c.cS2RC("mzj"), "ㄇㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mz"), "ㄇㄠ")
+    XCTAssertEqual(c.cS2RC("mzk"), "ㄇㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mzf"), "ㄇㄠˊ")
+    XCTAssertEqual(c.cS2RC("mpf"), "ㄇㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mzj"), "ㄇㄠˇ")
+    XCTAssertEqual(c.cS2RC("mpj"), "ㄇㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mzk"), "ㄇㄠˋ")
+    XCTAssertEqual(c.cS2RC("mpk"), "ㄇㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mpf"), "ㄇㄡˊ")
+    XCTAssertEqual(c.cS2RC("mm"), "ㄇㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mpj"), "ㄇㄡˇ")
+    XCTAssertEqual(c.cS2RC("mmf"), "ㄇㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mpk"), "ㄇㄡˋ")
+    XCTAssertEqual(c.cS2RC("mmj"), "ㄇㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mm"), "ㄇㄢ")
+    XCTAssertEqual(c.cS2RC("mmk"), "ㄇㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mmf"), "ㄇㄢˊ")
+    XCTAssertEqual(c.cS2RC("mn"), "ㄇㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mmj"), "ㄇㄢˇ")
+    XCTAssertEqual(c.cS2RC("mnf"), "ㄇㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mmk"), "ㄇㄢˋ")
+    XCTAssertEqual(c.cS2RC("mnj"), "ㄇㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mn"), "ㄇㄣ")
+    XCTAssertEqual(c.cS2RC("mnk"), "ㄇㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mnf"), "ㄇㄣˊ")
+    XCTAssertEqual(c.cS2RC("mnd"), "ㄇㄣ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mnj"), "ㄇㄣˇ")
+    XCTAssertEqual(c.cS2RC("mt"), "ㄇㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mnk"), "ㄇㄣˋ")
+    XCTAssertEqual(c.cS2RC("mtf"), "ㄇㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mnd"), "ㄇㄣ˙")
+    XCTAssertEqual(c.cS2RC("mtj"), "ㄇㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mt"), "ㄇㄤ")
+    XCTAssertEqual(c.cS2RC("mtk"), "ㄇㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mtf"), "ㄇㄤˊ")
+    XCTAssertEqual(c.cS2RC("ml"), "ㄇㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mtj"), "ㄇㄤˇ")
+    XCTAssertEqual(c.cS2RC("mlf"), "ㄇㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mtk"), "ㄇㄤˋ")
+    XCTAssertEqual(c.cS2RC("mlj"), "ㄇㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ml"), "ㄇㄥ")
+    XCTAssertEqual(c.cS2RC("mlk"), "ㄇㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mlf"), "ㄇㄥˊ")
+    XCTAssertEqual(c.cS2RC("me"), "ㄇㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mlj"), "ㄇㄥˇ")
+    XCTAssertEqual(c.cS2RC("mef"), "ㄇㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mlk"), "ㄇㄥˋ")
+    XCTAssertEqual(c.cS2RC("mej"), "ㄇㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("me"), "ㄇㄧ")
+    XCTAssertEqual(c.cS2RC("mek"), "ㄇㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mef"), "ㄇㄧˊ")
+    XCTAssertEqual(c.cS2RC("mew"), "ㄇㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mej"), "ㄇㄧˇ")
+    XCTAssertEqual(c.cS2RC("mewf"), "ㄇㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mek"), "ㄇㄧˋ")
+    XCTAssertEqual(c.cS2RC("mewk"), "ㄇㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mew"), "ㄇㄧㄝ")
+    XCTAssertEqual(c.cS2RC("mez"), "ㄇㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mewf"), "ㄇㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("mezf"), "ㄇㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mewk"), "ㄇㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("mezj"), "ㄇㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mez"), "ㄇㄧㄠ")
+    XCTAssertEqual(c.cS2RC("mezk"), "ㄇㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mezf"), "ㄇㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("mepf"), "ㄇㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mezj"), "ㄇㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("mepj"), "ㄇㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mezk"), "ㄇㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("mepk"), "ㄇㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mepf"), "ㄇㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("mem"), "ㄇㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mepj"), "ㄇㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("memf"), "ㄇㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mepk"), "ㄇㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("memj"), "ㄇㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mem"), "ㄇㄧㄢ")
+    XCTAssertEqual(c.cS2RC("memk"), "ㄇㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("memf"), "ㄇㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("men"), "ㄇㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("memj"), "ㄇㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("menf"), "ㄇㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("memk"), "ㄇㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("menj"), "ㄇㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("men"), "ㄇㄧㄣ")
+    XCTAssertEqual(c.cS2RC("melf"), "ㄇㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("menf"), "ㄇㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("melj"), "ㄇㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("menj"), "ㄇㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("melk"), "ㄇㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("melf"), "ㄇㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("mxf"), "ㄇㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("melj"), "ㄇㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("mxj"), "ㄇㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("melk"), "ㄇㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("mxk"), "ㄇㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mxf"), "ㄇㄨˊ")
+    XCTAssertEqual(c.cS2RC("fa"), "ㄈㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mxj"), "ㄇㄨˇ")
+    XCTAssertEqual(c.cS2RC("faf"), "ㄈㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mxk"), "ㄇㄨˋ")
+    XCTAssertEqual(c.cS2RC("faj"), "ㄈㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fa"), "ㄈㄚ")
+    XCTAssertEqual(c.cS2RC("fak"), "ㄈㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("faf"), "ㄈㄚˊ")
+    XCTAssertEqual(c.cS2RC("fof"), "ㄈㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("faj"), "ㄈㄚˇ")
+    XCTAssertEqual(c.cS2RC("fq"), "ㄈㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fak"), "ㄈㄚˋ")
+    XCTAssertEqual(c.cS2RC("fqf"), "ㄈㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fof"), "ㄈㄛˊ")
+    XCTAssertEqual(c.cS2RC("fqj"), "ㄈㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fq"), "ㄈㄟ")
+    XCTAssertEqual(c.cS2RC("fqk"), "ㄈㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fqf"), "ㄈㄟˊ")
+    XCTAssertEqual(c.cS2RC("fp"), "ㄈㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fqj"), "ㄈㄟˇ")
+    XCTAssertEqual(c.cS2RC("fpf"), "ㄈㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fqk"), "ㄈㄟˋ")
+    XCTAssertEqual(c.cS2RC("fpj"), "ㄈㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fp"), "ㄈㄡ")
+    XCTAssertEqual(c.cS2RC("fpk"), "ㄈㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fpf"), "ㄈㄡˊ")
+    XCTAssertEqual(c.cS2RC("fm"), "ㄈㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fpj"), "ㄈㄡˇ")
+    XCTAssertEqual(c.cS2RC("fmf"), "ㄈㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fpk"), "ㄈㄡˋ")
+    XCTAssertEqual(c.cS2RC("fmj"), "ㄈㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fm"), "ㄈㄢ")
+    XCTAssertEqual(c.cS2RC("fmk"), "ㄈㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmf"), "ㄈㄢˊ")
+    XCTAssertEqual(c.cS2RC("fn"), "ㄈㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmj"), "ㄈㄢˇ")
+    XCTAssertEqual(c.cS2RC("fnf"), "ㄈㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmk"), "ㄈㄢˋ")
+    XCTAssertEqual(c.cS2RC("fnj"), "ㄈㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fn"), "ㄈㄣ")
+    XCTAssertEqual(c.cS2RC("fnk"), "ㄈㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fnf"), "ㄈㄣˊ")
+    XCTAssertEqual(c.cS2RC("fnd"), "ㄈㄣ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fnj"), "ㄈㄣˇ")
+    XCTAssertEqual(c.cS2RC("ft"), "ㄈㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fnk"), "ㄈㄣˋ")
+    XCTAssertEqual(c.cS2RC("ftf"), "ㄈㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fnd"), "ㄈㄣ˙")
+    XCTAssertEqual(c.cS2RC("ftj"), "ㄈㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ft"), "ㄈㄤ")
+    XCTAssertEqual(c.cS2RC("ftk"), "ㄈㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ftf"), "ㄈㄤˊ")
+    XCTAssertEqual(c.cS2RC("fl"), "ㄈㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ftj"), "ㄈㄤˇ")
+    XCTAssertEqual(c.cS2RC("flf"), "ㄈㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ftk"), "ㄈㄤˋ")
+    XCTAssertEqual(c.cS2RC("flj"), "ㄈㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fl"), "ㄈㄥ")
+    XCTAssertEqual(c.cS2RC("flk"), "ㄈㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("flf"), "ㄈㄥˊ")
+    XCTAssertEqual(c.cS2RC("fezk"), "ㄈㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("flj"), "ㄈㄥˇ")
+    XCTAssertEqual(c.cS2RC("fx"), "ㄈㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("flk"), "ㄈㄥˋ")
+    XCTAssertEqual(c.cS2RC("fxf"), "ㄈㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fezk"), "ㄈㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("fxj"), "ㄈㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fx"), "ㄈㄨ")
+    XCTAssertEqual(c.cS2RC("fxk"), "ㄈㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fxf"), "ㄈㄨˊ")
+    XCTAssertEqual(c.cS2RC("da"), "ㄉㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fxj"), "ㄈㄨˇ")
+    XCTAssertEqual(c.cS2RC("daf"), "ㄉㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fxk"), "ㄈㄨˋ")
+    XCTAssertEqual(c.cS2RC("daj"), "ㄉㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("da"), "ㄉㄚ")
+    XCTAssertEqual(c.cS2RC("dak"), "ㄉㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("daf"), "ㄉㄚˊ")
+    XCTAssertEqual(c.cS2RC("dad"), "ㄉㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("daj"), "ㄉㄚˇ")
+    XCTAssertEqual(c.cS2RC("dr"), "ㄉㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dak"), "ㄉㄚˋ")
+    XCTAssertEqual(c.cS2RC("drf"), "ㄉㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dad"), "ㄉㄚ˙")
+    XCTAssertEqual(c.cS2RC("drd"), "ㄉㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dr"), "ㄉㄜ")
+    XCTAssertEqual(c.cS2RC("di"), "ㄉㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("drf"), "ㄉㄜˊ")
+    XCTAssertEqual(c.cS2RC("dij"), "ㄉㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("drd"), "ㄉㄜ˙")
+    XCTAssertEqual(c.cS2RC("dik"), "ㄉㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("di"), "ㄉㄞ")
+    XCTAssertEqual(c.cS2RC("dqj"), "ㄉㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dij"), "ㄉㄞˇ")
+    XCTAssertEqual(c.cS2RC("dz"), "ㄉㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dik"), "ㄉㄞˋ")
+    XCTAssertEqual(c.cS2RC("dzf"), "ㄉㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dqj"), "ㄉㄟˇ")
+    XCTAssertEqual(c.cS2RC("dzj"), "ㄉㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dz"), "ㄉㄠ")
+    XCTAssertEqual(c.cS2RC("dzk"), "ㄉㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dzf"), "ㄉㄠˊ")
+    XCTAssertEqual(c.cS2RC("dp"), "ㄉㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dzj"), "ㄉㄠˇ")
+    XCTAssertEqual(c.cS2RC("dpf"), "ㄉㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dzk"), "ㄉㄠˋ")
+    XCTAssertEqual(c.cS2RC("dpj"), "ㄉㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dp"), "ㄉㄡ")
+    XCTAssertEqual(c.cS2RC("dpk"), "ㄉㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dpf"), "ㄉㄡˊ")
+    XCTAssertEqual(c.cS2RC("dm"), "ㄉㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dpj"), "ㄉㄡˇ")
+    XCTAssertEqual(c.cS2RC("dmj"), "ㄉㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dpk"), "ㄉㄡˋ")
+    XCTAssertEqual(c.cS2RC("dmk"), "ㄉㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dm"), "ㄉㄢ")
+    XCTAssertEqual(c.cS2RC("dnk"), "ㄉㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dmj"), "ㄉㄢˇ")
+    XCTAssertEqual(c.cS2RC("dt"), "ㄉㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dmk"), "ㄉㄢˋ")
+    XCTAssertEqual(c.cS2RC("dtj"), "ㄉㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dnk"), "ㄉㄣˋ")
+    XCTAssertEqual(c.cS2RC("dtk"), "ㄉㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dt"), "ㄉㄤ")
+    XCTAssertEqual(c.cS2RC("dl"), "ㄉㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dtj"), "ㄉㄤˇ")
+    XCTAssertEqual(c.cS2RC("dlj"), "ㄉㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dtk"), "ㄉㄤˋ")
+    XCTAssertEqual(c.cS2RC("dlk"), "ㄉㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dl"), "ㄉㄥ")
+    XCTAssertEqual(c.cS2RC("de"), "ㄉㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dlj"), "ㄉㄥˇ")
+    XCTAssertEqual(c.cS2RC("def"), "ㄉㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dlk"), "ㄉㄥˋ")
+    XCTAssertEqual(c.cS2RC("dej"), "ㄉㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("de"), "ㄉㄧ")
+    XCTAssertEqual(c.cS2RC("dek"), "ㄉㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("def"), "ㄉㄧˊ")
+    XCTAssertEqual(c.cS2RC("deaj"), "ㄉㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dej"), "ㄉㄧˇ")
+    XCTAssertEqual(c.cS2RC("dew"), "ㄉㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dek"), "ㄉㄧˋ")
+    XCTAssertEqual(c.cS2RC("dewf"), "ㄉㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("deaj"), "ㄉㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("dewj"), "ㄉㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dew"), "ㄉㄧㄝ")
+    XCTAssertEqual(c.cS2RC("dewk"), "ㄉㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dewf"), "ㄉㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("dez"), "ㄉㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dewj"), "ㄉㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("dezj"), "ㄉㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dewk"), "ㄉㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("dezk"), "ㄉㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dez"), "ㄉㄧㄠ")
+    XCTAssertEqual(c.cS2RC("dep"), "ㄉㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dezj"), "ㄉㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("dem"), "ㄉㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dezk"), "ㄉㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("demf"), "ㄉㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dep"), "ㄉㄧㄡ")
+    XCTAssertEqual(c.cS2RC("demj"), "ㄉㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dem"), "ㄉㄧㄢ")
+    XCTAssertEqual(c.cS2RC("demk"), "ㄉㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("demf"), "ㄉㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("del"), "ㄉㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("demj"), "ㄉㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("delf"), "ㄉㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("demk"), "ㄉㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("delj"), "ㄉㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("del"), "ㄉㄧㄥ")
+    XCTAssertEqual(c.cS2RC("delk"), "ㄉㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("delf"), "ㄉㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("dx"), "ㄉㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("delj"), "ㄉㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("dxf"), "ㄉㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("delk"), "ㄉㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("dxj"), "ㄉㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dx"), "ㄉㄨ")
+    XCTAssertEqual(c.cS2RC("dxk"), "ㄉㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxf"), "ㄉㄨˊ")
+    XCTAssertEqual(c.cS2RC("dxo"), "ㄉㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxj"), "ㄉㄨˇ")
+    XCTAssertEqual(c.cS2RC("dxof"), "ㄉㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxk"), "ㄉㄨˋ")
+    XCTAssertEqual(c.cS2RC("dxoj"), "ㄉㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxo"), "ㄉㄨㄛ")
+    XCTAssertEqual(c.cS2RC("dxok"), "ㄉㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxof"), "ㄉㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("dxod"), "ㄉㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxoj"), "ㄉㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("dxq"), "ㄉㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxok"), "ㄉㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("dxqj"), "ㄉㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxod"), "ㄉㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("dxqk"), "ㄉㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxq"), "ㄉㄨㄟ")
+    XCTAssertEqual(c.cS2RC("dxm"), "ㄉㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxqj"), "ㄉㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("dxmj"), "ㄉㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxqk"), "ㄉㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("dxmk"), "ㄉㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxm"), "ㄉㄨㄢ")
+    XCTAssertEqual(c.cS2RC("dxn"), "ㄉㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxmj"), "ㄉㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("dxnj"), "ㄉㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxmk"), "ㄉㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("dxnk"), "ㄉㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxn"), "ㄉㄨㄣ")
+    XCTAssertEqual(c.cS2RC("dxl"), "ㄉㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxnj"), "ㄉㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("dxlj"), "ㄉㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxnk"), "ㄉㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("dxlk"), "ㄉㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxl"), "ㄉㄨㄥ")
+    XCTAssertEqual(c.cS2RC("ta"), "ㄊㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxlj"), "ㄉㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("taj"), "ㄊㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxlk"), "ㄉㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("tak"), "ㄊㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ta"), "ㄊㄚ")
+    XCTAssertEqual(c.cS2RC("trk"), "ㄊㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("taj"), "ㄊㄚˇ")
+    XCTAssertEqual(c.cS2RC("ti"), "ㄊㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tak"), "ㄊㄚˋ")
+    XCTAssertEqual(c.cS2RC("tif"), "ㄊㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("trk"), "ㄊㄜˋ")
+    XCTAssertEqual(c.cS2RC("tij"), "ㄊㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ti"), "ㄊㄞ")
+    XCTAssertEqual(c.cS2RC("tik"), "ㄊㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tif"), "ㄊㄞˊ")
+    XCTAssertEqual(c.cS2RC("tid"), "ㄊㄞ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tij"), "ㄊㄞˇ")
+    XCTAssertEqual(c.cS2RC("tz"), "ㄊㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tik"), "ㄊㄞˋ")
+    XCTAssertEqual(c.cS2RC("tzf"), "ㄊㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tid"), "ㄊㄞ˙")
+    XCTAssertEqual(c.cS2RC("tzj"), "ㄊㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tz"), "ㄊㄠ")
+    XCTAssertEqual(c.cS2RC("tzk"), "ㄊㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tzf"), "ㄊㄠˊ")
+    XCTAssertEqual(c.cS2RC("tzd"), "ㄊㄠ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tzj"), "ㄊㄠˇ")
+    XCTAssertEqual(c.cS2RC("tp"), "ㄊㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tzk"), "ㄊㄠˋ")
+    XCTAssertEqual(c.cS2RC("tpf"), "ㄊㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tzd"), "ㄊㄠ˙")
+    XCTAssertEqual(c.cS2RC("tpj"), "ㄊㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tp"), "ㄊㄡ")
+    XCTAssertEqual(c.cS2RC("tpk"), "ㄊㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tpf"), "ㄊㄡˊ")
+    XCTAssertEqual(c.cS2RC("tpd"), "ㄊㄡ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tpj"), "ㄊㄡˇ")
+    XCTAssertEqual(c.cS2RC("tm"), "ㄊㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tpk"), "ㄊㄡˋ")
+    XCTAssertEqual(c.cS2RC("tmf"), "ㄊㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tpd"), "ㄊㄡ˙")
+    XCTAssertEqual(c.cS2RC("tmj"), "ㄊㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tm"), "ㄊㄢ")
+    XCTAssertEqual(c.cS2RC("tmk"), "ㄊㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tmf"), "ㄊㄢˊ")
+    XCTAssertEqual(c.cS2RC("tt"), "ㄊㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tmj"), "ㄊㄢˇ")
+    XCTAssertEqual(c.cS2RC("ttf"), "ㄊㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tmk"), "ㄊㄢˋ")
+    XCTAssertEqual(c.cS2RC("ttj"), "ㄊㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tt"), "ㄊㄤ")
+    XCTAssertEqual(c.cS2RC("ttk"), "ㄊㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttf"), "ㄊㄤˊ")
+    XCTAssertEqual(c.cS2RC("tl"), "ㄊㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttj"), "ㄊㄤˇ")
+    XCTAssertEqual(c.cS2RC("tlf"), "ㄊㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ttk"), "ㄊㄤˋ")
+    XCTAssertEqual(c.cS2RC("tlk"), "ㄊㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tl"), "ㄊㄥ")
+    XCTAssertEqual(c.cS2RC("te"), "ㄊㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tlf"), "ㄊㄥˊ")
+    XCTAssertEqual(c.cS2RC("tef"), "ㄊㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tlk"), "ㄊㄥˋ")
+    XCTAssertEqual(c.cS2RC("tej"), "ㄊㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("te"), "ㄊㄧ")
+    XCTAssertEqual(c.cS2RC("tek"), "ㄊㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tef"), "ㄊㄧˊ")
+    XCTAssertEqual(c.cS2RC("tew"), "ㄊㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tej"), "ㄊㄧˇ")
+    XCTAssertEqual(c.cS2RC("tewf"), "ㄊㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tek"), "ㄊㄧˋ")
+    XCTAssertEqual(c.cS2RC("tewj"), "ㄊㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tew"), "ㄊㄧㄝ")
+    XCTAssertEqual(c.cS2RC("tewk"), "ㄊㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tewf"), "ㄊㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("tez"), "ㄊㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tewj"), "ㄊㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("tezf"), "ㄊㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tewk"), "ㄊㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("tezj"), "ㄊㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tez"), "ㄊㄧㄠ")
+    XCTAssertEqual(c.cS2RC("tezk"), "ㄊㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tezf"), "ㄊㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("tem"), "ㄊㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tezj"), "ㄊㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("temf"), "ㄊㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tezk"), "ㄊㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("temj"), "ㄊㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tem"), "ㄊㄧㄢ")
+    XCTAssertEqual(c.cS2RC("temk"), "ㄊㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("temf"), "ㄊㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("tel"), "ㄊㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("temj"), "ㄊㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("telf"), "ㄊㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("temk"), "ㄊㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("telj"), "ㄊㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tel"), "ㄊㄧㄥ")
+    XCTAssertEqual(c.cS2RC("telk"), "ㄊㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("telf"), "ㄊㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("tx"), "ㄊㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("telj"), "ㄊㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("txf"), "ㄊㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("telk"), "ㄊㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("txj"), "ㄊㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tx"), "ㄊㄨ")
+    XCTAssertEqual(c.cS2RC("txk"), "ㄊㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txf"), "ㄊㄨˊ")
+    XCTAssertEqual(c.cS2RC("txo"), "ㄊㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txj"), "ㄊㄨˇ")
+    XCTAssertEqual(c.cS2RC("txof"), "ㄊㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txk"), "ㄊㄨˋ")
+    XCTAssertEqual(c.cS2RC("txoj"), "ㄊㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txo"), "ㄊㄨㄛ")
+    XCTAssertEqual(c.cS2RC("txok"), "ㄊㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txof"), "ㄊㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("txq"), "ㄊㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txoj"), "ㄊㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("txqf"), "ㄊㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txok"), "ㄊㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("txqj"), "ㄊㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txq"), "ㄊㄨㄟ")
+    XCTAssertEqual(c.cS2RC("txqk"), "ㄊㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txqf"), "ㄊㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("txm"), "ㄊㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txqj"), "ㄊㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("txmf"), "ㄊㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txqk"), "ㄊㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("txmj"), "ㄊㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txm"), "ㄊㄨㄢ")
+    XCTAssertEqual(c.cS2RC("txmk"), "ㄊㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txmf"), "ㄊㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("txn"), "ㄊㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txmj"), "ㄊㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("txnf"), "ㄊㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txmk"), "ㄊㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("txnj"), "ㄊㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txn"), "ㄊㄨㄣ")
+    XCTAssertEqual(c.cS2RC("txnk"), "ㄊㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txnf"), "ㄊㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("txl"), "ㄊㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txnj"), "ㄊㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("txlf"), "ㄊㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txnk"), "ㄊㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("txlj"), "ㄊㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txl"), "ㄊㄨㄥ")
+    XCTAssertEqual(c.cS2RC("txlk"), "ㄊㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txlf"), "ㄊㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("na"), "ㄋㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txlj"), "ㄊㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("naf"), "ㄋㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txlk"), "ㄊㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("naj"), "ㄋㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("na"), "ㄋㄚ")
+    XCTAssertEqual(c.cS2RC("nak"), "ㄋㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("naf"), "ㄋㄚˊ")
+    XCTAssertEqual(c.cS2RC("nad"), "ㄋㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("naj"), "ㄋㄚˇ")
+    XCTAssertEqual(c.cS2RC("nrk"), "ㄋㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nak"), "ㄋㄚˋ")
+    XCTAssertEqual(c.cS2RC("nrd"), "ㄋㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nad"), "ㄋㄚ˙")
+    XCTAssertEqual(c.cS2RC("nif"), "ㄋㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nrk"), "ㄋㄜˋ")
+    XCTAssertEqual(c.cS2RC("nij"), "ㄋㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nrd"), "ㄋㄜ˙")
+    XCTAssertEqual(c.cS2RC("nik"), "ㄋㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nif"), "ㄋㄞˊ")
+    XCTAssertEqual(c.cS2RC("nqf"), "ㄋㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nij"), "ㄋㄞˇ")
+    XCTAssertEqual(c.cS2RC("nqj"), "ㄋㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nik"), "ㄋㄞˋ")
+    XCTAssertEqual(c.cS2RC("nqk"), "ㄋㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nqf"), "ㄋㄟˊ")
+    XCTAssertEqual(c.cS2RC("nz"), "ㄋㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nqj"), "ㄋㄟˇ")
+    XCTAssertEqual(c.cS2RC("nzf"), "ㄋㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nqk"), "ㄋㄟˋ")
+    XCTAssertEqual(c.cS2RC("nzj"), "ㄋㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nz"), "ㄋㄠ")
+    XCTAssertEqual(c.cS2RC("nzk"), "ㄋㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nzf"), "ㄋㄠˊ")
+    XCTAssertEqual(c.cS2RC("npf"), "ㄋㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nzj"), "ㄋㄠˇ")
+    XCTAssertEqual(c.cS2RC("npj"), "ㄋㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nzk"), "ㄋㄠˋ")
+    XCTAssertEqual(c.cS2RC("npk"), "ㄋㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("npf"), "ㄋㄡˊ")
+    XCTAssertEqual(c.cS2RC("nm"), "ㄋㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("npj"), "ㄋㄡˇ")
+    XCTAssertEqual(c.cS2RC("nmf"), "ㄋㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("npk"), "ㄋㄡˋ")
+    XCTAssertEqual(c.cS2RC("nmj"), "ㄋㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nm"), "ㄋㄢ")
+    XCTAssertEqual(c.cS2RC("nmk"), "ㄋㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nmf"), "ㄋㄢˊ")
+    XCTAssertEqual(c.cS2RC("nnj"), "ㄋㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nmj"), "ㄋㄢˇ")
+    XCTAssertEqual(c.cS2RC("nnk"), "ㄋㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nmk"), "ㄋㄢˋ")
+    XCTAssertEqual(c.cS2RC("nt"), "ㄋㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nnj"), "ㄋㄣˇ")
+    XCTAssertEqual(c.cS2RC("ntf"), "ㄋㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nnk"), "ㄋㄣˋ")
+    XCTAssertEqual(c.cS2RC("ntj"), "ㄋㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nt"), "ㄋㄤ")
+    XCTAssertEqual(c.cS2RC("ntk"), "ㄋㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ntf"), "ㄋㄤˊ")
+    XCTAssertEqual(c.cS2RC("ntd"), "ㄋㄤ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ntj"), "ㄋㄤˇ")
+    XCTAssertEqual(c.cS2RC("nlf"), "ㄋㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ntk"), "ㄋㄤˋ")
+    XCTAssertEqual(c.cS2RC("nlj"), "ㄋㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ntd"), "ㄋㄤ˙")
+    XCTAssertEqual(c.cS2RC("ne"), "ㄋㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nlf"), "ㄋㄥˊ")
+    XCTAssertEqual(c.cS2RC("nef"), "ㄋㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nlj"), "ㄋㄥˇ")
+    XCTAssertEqual(c.cS2RC("nej"), "ㄋㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ne"), "ㄋㄧ")
+    XCTAssertEqual(c.cS2RC("nek"), "ㄋㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nef"), "ㄋㄧˊ")
+    XCTAssertEqual(c.cS2RC("new"), "ㄋㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nej"), "ㄋㄧˇ")
+    XCTAssertEqual(c.cS2RC("newf"), "ㄋㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nek"), "ㄋㄧˋ")
+    XCTAssertEqual(c.cS2RC("newk"), "ㄋㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("new"), "ㄋㄧㄝ")
+    XCTAssertEqual(c.cS2RC("nezj"), "ㄋㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("newf"), "ㄋㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("nezk"), "ㄋㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("newk"), "ㄋㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("nep"), "ㄋㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nezj"), "ㄋㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("nepf"), "ㄋㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nezk"), "ㄋㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("nepj"), "ㄋㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nep"), "ㄋㄧㄡ")
+    XCTAssertEqual(c.cS2RC("nepk"), "ㄋㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nepf"), "ㄋㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("nem"), "ㄋㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nepj"), "ㄋㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("nemf"), "ㄋㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nepk"), "ㄋㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("nemj"), "ㄋㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nem"), "ㄋㄧㄢ")
+    XCTAssertEqual(c.cS2RC("nemk"), "ㄋㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nemf"), "ㄋㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("nen"), "ㄋㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nemj"), "ㄋㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("nenf"), "ㄋㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nemk"), "ㄋㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("nenj"), "ㄋㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nen"), "ㄋㄧㄣ")
+    XCTAssertEqual(c.cS2RC("nenk"), "ㄋㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nenf"), "ㄋㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("netf"), "ㄋㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nenj"), "ㄋㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("netj"), "ㄋㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nenk"), "ㄋㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("netk"), "ㄋㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("netf"), "ㄋㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("nelf"), "ㄋㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("netj"), "ㄋㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("nelj"), "ㄋㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("netk"), "ㄋㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("nelk"), "ㄋㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nelf"), "ㄋㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("nxf"), "ㄋㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nelj"), "ㄋㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("nxj"), "ㄋㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nelk"), "ㄋㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("nxk"), "ㄋㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxf"), "ㄋㄨˊ")
+    XCTAssertEqual(c.cS2RC("nxof"), "ㄋㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxj"), "ㄋㄨˇ")
+    XCTAssertEqual(c.cS2RC("nxoj"), "ㄋㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxk"), "ㄋㄨˋ")
+    XCTAssertEqual(c.cS2RC("nxok"), "ㄋㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxof"), "ㄋㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("nxqf"), "ㄋㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxoj"), "ㄋㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("nxmf"), "ㄋㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxok"), "ㄋㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("nxmj"), "ㄋㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxqf"), "ㄋㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("nxmk"), "ㄋㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxmf"), "ㄋㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("nxnf"), "ㄋㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxmj"), "ㄋㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("nxlf"), "ㄋㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxmk"), "ㄋㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("nxlj"), "ㄋㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxnf"), "ㄋㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("nxlk"), "ㄋㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxlf"), "ㄋㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("nuf"), "ㄋㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxlj"), "ㄋㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("nuj"), "ㄋㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxlk"), "ㄋㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("nuk"), "ㄋㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuf"), "ㄋㄩˊ")
+    XCTAssertEqual(c.cS2RC("nuwk"), "ㄋㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuj"), "ㄋㄩˇ")
+    XCTAssertEqual(c.cS2RC("la"), "ㄌㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuk"), "ㄋㄩˋ")
+    XCTAssertEqual(c.cS2RC("laf"), "ㄌㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuwk"), "ㄋㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("laj"), "ㄌㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("la"), "ㄌㄚ")
+    XCTAssertEqual(c.cS2RC("lak"), "ㄌㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("laf"), "ㄌㄚˊ")
+    XCTAssertEqual(c.cS2RC("lad"), "ㄌㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("laj"), "ㄌㄚˇ")
+    XCTAssertEqual(c.cS2RC("lo"), "ㄌㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lak"), "ㄌㄚˋ")
+    XCTAssertEqual(c.cS2RC("lod"), "ㄌㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lad"), "ㄌㄚ˙")
+    XCTAssertEqual(c.cS2RC("lr"), "ㄌㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lo"), "ㄌㄛ")
+    XCTAssertEqual(c.cS2RC("lrf"), "ㄌㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lod"), "ㄌㄛ˙")
+    XCTAssertEqual(c.cS2RC("lrk"), "ㄌㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lr"), "ㄌㄜ")
+    XCTAssertEqual(c.cS2RC("lrd"), "ㄌㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lrf"), "ㄌㄜˊ")
+    XCTAssertEqual(c.cS2RC("lif"), "ㄌㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lrk"), "ㄌㄜˋ")
+    XCTAssertEqual(c.cS2RC("lij"), "ㄌㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lrd"), "ㄌㄜ˙")
+    XCTAssertEqual(c.cS2RC("lik"), "ㄌㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lif"), "ㄌㄞˊ")
+    XCTAssertEqual(c.cS2RC("lq"), "ㄌㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lij"), "ㄌㄞˇ")
+    XCTAssertEqual(c.cS2RC("lqf"), "ㄌㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lik"), "ㄌㄞˋ")
+    XCTAssertEqual(c.cS2RC("lqj"), "ㄌㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lq"), "ㄌㄟ")
+    XCTAssertEqual(c.cS2RC("lqk"), "ㄌㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lqf"), "ㄌㄟˊ")
+    XCTAssertEqual(c.cS2RC("lqd"), "ㄌㄟ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lqj"), "ㄌㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lqk"), "ㄌㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lqd"), "ㄌㄟ˙")
   }
 }

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Eten26_B.swift

@@ -12,490 +12,490 @@ import XCTest
 
 extension TekkonTestsKeyboardArrangments {
   func testETen26KeysB() throws {
-    var composer = Tekkon.Composer(arrange: .ofETen26)
+    var c = Tekkon.Composer(arrange: .ofETen26)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lz"), "ㄌㄠ")
+    XCTAssertEqual(c.cS2RC("lz"), "ㄌㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lzf"), "ㄌㄠˊ")
+    XCTAssertEqual(c.cS2RC("lzf"), "ㄌㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lzj"), "ㄌㄠˇ")
+    XCTAssertEqual(c.cS2RC("lzj"), "ㄌㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lzk"), "ㄌㄠˋ")
+    XCTAssertEqual(c.cS2RC("lzk"), "ㄌㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lp"), "ㄌㄡ")
+    XCTAssertEqual(c.cS2RC("lp"), "ㄌㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lpf"), "ㄌㄡˊ")
+    XCTAssertEqual(c.cS2RC("lpf"), "ㄌㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lpj"), "ㄌㄡˇ")
+    XCTAssertEqual(c.cS2RC("lpj"), "ㄌㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lpk"), "ㄌㄡˋ")
+    XCTAssertEqual(c.cS2RC("lpk"), "ㄌㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lpd"), "ㄌㄡ˙")
+    XCTAssertEqual(c.cS2RC("lpd"), "ㄌㄡ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lmf"), "ㄌㄢˊ")
+    XCTAssertEqual(c.cS2RC("lmf"), "ㄌㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lmj"), "ㄌㄢˇ")
+    XCTAssertEqual(c.cS2RC("lmj"), "ㄌㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lmk"), "ㄌㄢˋ")
+    XCTAssertEqual(c.cS2RC("lmk"), "ㄌㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lt"), "ㄌㄤ")
+    XCTAssertEqual(c.cS2RC("lt"), "ㄌㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ltf"), "ㄌㄤˊ")
+    XCTAssertEqual(c.cS2RC("ltf"), "ㄌㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ltj"), "ㄌㄤˇ")
+    XCTAssertEqual(c.cS2RC("ltj"), "ㄌㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ltk"), "ㄌㄤˋ")
+    XCTAssertEqual(c.cS2RC("ltk"), "ㄌㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ll"), "ㄌㄥ")
+    XCTAssertEqual(c.cS2RC("ll"), "ㄌㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("llf"), "ㄌㄥˊ")
+    XCTAssertEqual(c.cS2RC("llf"), "ㄌㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("llj"), "ㄌㄥˇ")
+    XCTAssertEqual(c.cS2RC("llj"), "ㄌㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("llk"), "ㄌㄥˋ")
+    XCTAssertEqual(c.cS2RC("llk"), "ㄌㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("le"), "ㄌㄧ")
+    XCTAssertEqual(c.cS2RC("le"), "ㄌㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lef"), "ㄌㄧˊ")
+    XCTAssertEqual(c.cS2RC("lef"), "ㄌㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lej"), "ㄌㄧˇ")
+    XCTAssertEqual(c.cS2RC("lej"), "ㄌㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lek"), "ㄌㄧˋ")
+    XCTAssertEqual(c.cS2RC("lek"), "ㄌㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("led"), "ㄌㄧ˙")
+    XCTAssertEqual(c.cS2RC("led"), "ㄌㄧ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leaj"), "ㄌㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("leaj"), "ㄌㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lew"), "ㄌㄧㄝ")
+    XCTAssertEqual(c.cS2RC("lew"), "ㄌㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lewf"), "ㄌㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("lewf"), "ㄌㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lewj"), "ㄌㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("lewj"), "ㄌㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lewk"), "ㄌㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("lewk"), "ㄌㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lez"), "ㄌㄧㄠ")
+    XCTAssertEqual(c.cS2RC("lez"), "ㄌㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lezf"), "ㄌㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("lezf"), "ㄌㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lezj"), "ㄌㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("lezj"), "ㄌㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lezk"), "ㄌㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("lezk"), "ㄌㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lep"), "ㄌㄧㄡ")
+    XCTAssertEqual(c.cS2RC("lep"), "ㄌㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lepf"), "ㄌㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("lepf"), "ㄌㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lepj"), "ㄌㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("lepj"), "ㄌㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lepk"), "ㄌㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("lepk"), "ㄌㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lem"), "ㄌㄧㄢ")
+    XCTAssertEqual(c.cS2RC("lem"), "ㄌㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lemf"), "ㄌㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("lemf"), "ㄌㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lemj"), "ㄌㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("lemj"), "ㄌㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lemk"), "ㄌㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("lemk"), "ㄌㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lenf"), "ㄌㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("lenf"), "ㄌㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lenj"), "ㄌㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("lenj"), "ㄌㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lenk"), "ㄌㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("lenk"), "ㄌㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("letf"), "ㄌㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("letf"), "ㄌㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("letj"), "ㄌㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("letj"), "ㄌㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("letk"), "ㄌㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("letk"), "ㄌㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lel"), "ㄌㄧㄥ")
+    XCTAssertEqual(c.cS2RC("lel"), "ㄌㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lelf"), "ㄌㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("lelf"), "ㄌㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lelj"), "ㄌㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("lelj"), "ㄌㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lelk"), "ㄌㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("lelk"), "ㄌㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lx"), "ㄌㄨ")
+    XCTAssertEqual(c.cS2RC("lx"), "ㄌㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxf"), "ㄌㄨˊ")
+    XCTAssertEqual(c.cS2RC("lxf"), "ㄌㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxj"), "ㄌㄨˇ")
+    XCTAssertEqual(c.cS2RC("lxj"), "ㄌㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxk"), "ㄌㄨˋ")
+    XCTAssertEqual(c.cS2RC("lxk"), "ㄌㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxo"), "ㄌㄨㄛ")
+    XCTAssertEqual(c.cS2RC("lxo"), "ㄌㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxof"), "ㄌㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("lxof"), "ㄌㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxoj"), "ㄌㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("lxoj"), "ㄌㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxok"), "ㄌㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("lxok"), "ㄌㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxod"), "ㄌㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("lxod"), "ㄌㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxmf"), "ㄌㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("lxmf"), "ㄌㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxmj"), "ㄌㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("lxmj"), "ㄌㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxmk"), "ㄌㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("lxmk"), "ㄌㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxn"), "ㄌㄨㄣ")
+    XCTAssertEqual(c.cS2RC("lxn"), "ㄌㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxnf"), "ㄌㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("lxnf"), "ㄌㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxnj"), "ㄌㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("lxnj"), "ㄌㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxnk"), "ㄌㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("lxnk"), "ㄌㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxl"), "ㄌㄨㄥ")
+    XCTAssertEqual(c.cS2RC("lxl"), "ㄌㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxlf"), "ㄌㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("lxlf"), "ㄌㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxlj"), "ㄌㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("lxlj"), "ㄌㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxlk"), "ㄌㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("lxlk"), "ㄌㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lu"), "ㄌㄩ")
+    XCTAssertEqual(c.cS2RC("lu"), "ㄌㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luf"), "ㄌㄩˊ")
+    XCTAssertEqual(c.cS2RC("luf"), "ㄌㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luj"), "ㄌㄩˇ")
+    XCTAssertEqual(c.cS2RC("luj"), "ㄌㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luk"), "ㄌㄩˋ")
+    XCTAssertEqual(c.cS2RC("luk"), "ㄌㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luw"), "ㄌㄩㄝ")
+    XCTAssertEqual(c.cS2RC("luw"), "ㄌㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luwj"), "ㄌㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("luwj"), "ㄌㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luwk"), "ㄌㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("luwk"), "ㄌㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lumf"), "ㄌㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("lumf"), "ㄌㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lumj"), "ㄌㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("lumj"), "ㄌㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("va"), "ㄍㄚ")
+    XCTAssertEqual(c.cS2RC("va"), "ㄍㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vaf"), "ㄍㄚˊ")
+    XCTAssertEqual(c.cS2RC("vaf"), "ㄍㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vaj"), "ㄍㄚˇ")
+    XCTAssertEqual(c.cS2RC("vaj"), "ㄍㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vak"), "ㄍㄚˋ")
+    XCTAssertEqual(c.cS2RC("vak"), "ㄍㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vad"), "ㄍㄚ˙")
+    XCTAssertEqual(c.cS2RC("vad"), "ㄍㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vr"), "ㄍㄜ")
+    XCTAssertEqual(c.cS2RC("vr"), "ㄍㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vrf"), "ㄍㄜˊ")
+    XCTAssertEqual(c.cS2RC("vrf"), "ㄍㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vrj"), "ㄍㄜˇ")
+    XCTAssertEqual(c.cS2RC("vrj"), "ㄍㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vrk"), "ㄍㄜˋ")
+    XCTAssertEqual(c.cS2RC("vrk"), "ㄍㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vrd"), "ㄍㄜ˙")
+    XCTAssertEqual(c.cS2RC("vrd"), "ㄍㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vi"), "ㄍㄞ")
+    XCTAssertEqual(c.cS2RC("vi"), "ㄍㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vij"), "ㄍㄞˇ")
+    XCTAssertEqual(c.cS2RC("vij"), "ㄍㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vik"), "ㄍㄞˋ")
+    XCTAssertEqual(c.cS2RC("vik"), "ㄍㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vqj"), "ㄍㄟˇ")
+    XCTAssertEqual(c.cS2RC("vqj"), "ㄍㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vz"), "ㄍㄠ")
+    XCTAssertEqual(c.cS2RC("vz"), "ㄍㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vzj"), "ㄍㄠˇ")
+    XCTAssertEqual(c.cS2RC("vzj"), "ㄍㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vzk"), "ㄍㄠˋ")
+    XCTAssertEqual(c.cS2RC("vzk"), "ㄍㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vp"), "ㄍㄡ")
+    XCTAssertEqual(c.cS2RC("vp"), "ㄍㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vpj"), "ㄍㄡˇ")
+    XCTAssertEqual(c.cS2RC("vpj"), "ㄍㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vpk"), "ㄍㄡˋ")
+    XCTAssertEqual(c.cS2RC("vpk"), "ㄍㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vm"), "ㄍㄢ")
+    XCTAssertEqual(c.cS2RC("vm"), "ㄍㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmj"), "ㄍㄢˇ")
+    XCTAssertEqual(c.cS2RC("vmj"), "ㄍㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vmk"), "ㄍㄢˋ")
+    XCTAssertEqual(c.cS2RC("vmk"), "ㄍㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vn"), "ㄍㄣ")
+    XCTAssertEqual(c.cS2RC("vn"), "ㄍㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vnf"), "ㄍㄣˊ")
+    XCTAssertEqual(c.cS2RC("vnf"), "ㄍㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vnj"), "ㄍㄣˇ")
+    XCTAssertEqual(c.cS2RC("vnj"), "ㄍㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vnk"), "ㄍㄣˋ")
+    XCTAssertEqual(c.cS2RC("vnk"), "ㄍㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vt"), "ㄍㄤ")
+    XCTAssertEqual(c.cS2RC("vt"), "ㄍㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vtj"), "ㄍㄤˇ")
+    XCTAssertEqual(c.cS2RC("vtj"), "ㄍㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vtk"), "ㄍㄤˋ")
+    XCTAssertEqual(c.cS2RC("vtk"), "ㄍㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vl"), "ㄍㄥ")
+    XCTAssertEqual(c.cS2RC("vl"), "ㄍㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vlj"), "ㄍㄥˇ")
+    XCTAssertEqual(c.cS2RC("vlj"), "ㄍㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vlk"), "ㄍㄥˋ")
+    XCTAssertEqual(c.cS2RC("vlk"), "ㄍㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vx"), "ㄍㄨ")
+    XCTAssertEqual(c.cS2RC("vx"), "ㄍㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxf"), "ㄍㄨˊ")
+    XCTAssertEqual(c.cS2RC("vxf"), "ㄍㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxj"), "ㄍㄨˇ")
+    XCTAssertEqual(c.cS2RC("vxj"), "ㄍㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxk"), "ㄍㄨˋ")
+    XCTAssertEqual(c.cS2RC("vxk"), "ㄍㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxa"), "ㄍㄨㄚ")
+    XCTAssertEqual(c.cS2RC("vxa"), "ㄍㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxaf"), "ㄍㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("vxaf"), "ㄍㄨㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxaj"), "ㄍㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("vxaj"), "ㄍㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxak"), "ㄍㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("vxak"), "ㄍㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxo"), "ㄍㄨㄛ")
+    XCTAssertEqual(c.cS2RC("vxo"), "ㄍㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxof"), "ㄍㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("vxof"), "ㄍㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxoj"), "ㄍㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("vxoj"), "ㄍㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxok"), "ㄍㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("vxok"), "ㄍㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxi"), "ㄍㄨㄞ")
+    XCTAssertEqual(c.cS2RC("vxi"), "ㄍㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxij"), "ㄍㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("vxij"), "ㄍㄨㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxik"), "ㄍㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("vxik"), "ㄍㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxq"), "ㄍㄨㄟ")
+    XCTAssertEqual(c.cS2RC("vxq"), "ㄍㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxqj"), "ㄍㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("vxqj"), "ㄍㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxqk"), "ㄍㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("vxqk"), "ㄍㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxm"), "ㄍㄨㄢ")
+    XCTAssertEqual(c.cS2RC("vxm"), "ㄍㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxmj"), "ㄍㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("vxmj"), "ㄍㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxmk"), "ㄍㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("vxmk"), "ㄍㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxn"), "ㄍㄨㄣ")
+    XCTAssertEqual(c.cS2RC("vxn"), "ㄍㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxnj"), "ㄍㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("vxnj"), "ㄍㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxnk"), "ㄍㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("vxnk"), "ㄍㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxt"), "ㄍㄨㄤ")
+    XCTAssertEqual(c.cS2RC("vxt"), "ㄍㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxtj"), "ㄍㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("vxtj"), "ㄍㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxtk"), "ㄍㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("vxtk"), "ㄍㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxl"), "ㄍㄨㄥ")
+    XCTAssertEqual(c.cS2RC("vxl"), "ㄍㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxlf"), "ㄍㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("vxlf"), "ㄍㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxlj"), "ㄍㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("vxlj"), "ㄍㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vxlk"), "ㄍㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("vxlk"), "ㄍㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ka"), "ㄎㄚ")
+    XCTAssertEqual(c.cS2RC("ka"), "ㄎㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kaj"), "ㄎㄚˇ")
+    XCTAssertEqual(c.cS2RC("kaj"), "ㄎㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kak"), "ㄎㄚˋ")
+    XCTAssertEqual(c.cS2RC("kak"), "ㄎㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kr"), "ㄎㄜ")
+    XCTAssertEqual(c.cS2RC("kr"), "ㄎㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("krf"), "ㄎㄜˊ")
+    XCTAssertEqual(c.cS2RC("krf"), "ㄎㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("krj"), "ㄎㄜˇ")
+    XCTAssertEqual(c.cS2RC("krj"), "ㄎㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("krk"), "ㄎㄜˋ")
+    XCTAssertEqual(c.cS2RC("krk"), "ㄎㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ki"), "ㄎㄞ")
+    XCTAssertEqual(c.cS2RC("ki"), "ㄎㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kij"), "ㄎㄞˇ")
+    XCTAssertEqual(c.cS2RC("kij"), "ㄎㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kik"), "ㄎㄞˋ")
+    XCTAssertEqual(c.cS2RC("kik"), "ㄎㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kz"), "ㄎㄠ")
+    XCTAssertEqual(c.cS2RC("kz"), "ㄎㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kzj"), "ㄎㄠˇ")
+    XCTAssertEqual(c.cS2RC("kzj"), "ㄎㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kzk"), "ㄎㄠˋ")
+    XCTAssertEqual(c.cS2RC("kzk"), "ㄎㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kp"), "ㄎㄡ")
+    XCTAssertEqual(c.cS2RC("kp"), "ㄎㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kpj"), "ㄎㄡˇ")
+    XCTAssertEqual(c.cS2RC("kpj"), "ㄎㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kpk"), "ㄎㄡˋ")
+    XCTAssertEqual(c.cS2RC("kpk"), "ㄎㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("km"), "ㄎㄢ")
+    XCTAssertEqual(c.cS2RC("km"), "ㄎㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kmj"), "ㄎㄢˇ")
+    XCTAssertEqual(c.cS2RC("kmj"), "ㄎㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kmk"), "ㄎㄢˋ")
+    XCTAssertEqual(c.cS2RC("kmk"), "ㄎㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kn"), "ㄎㄣ")
+    XCTAssertEqual(c.cS2RC("kn"), "ㄎㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("knj"), "ㄎㄣˇ")
+    XCTAssertEqual(c.cS2RC("knj"), "ㄎㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("knk"), "ㄎㄣˋ")
+    XCTAssertEqual(c.cS2RC("knk"), "ㄎㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kt"), "ㄎㄤ")
+    XCTAssertEqual(c.cS2RC("kt"), "ㄎㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ktf"), "ㄎㄤˊ")
+    XCTAssertEqual(c.cS2RC("ktf"), "ㄎㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ktj"), "ㄎㄤˇ")
+    XCTAssertEqual(c.cS2RC("ktj"), "ㄎㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ktk"), "ㄎㄤˋ")
+    XCTAssertEqual(c.cS2RC("ktk"), "ㄎㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kl"), "ㄎㄥ")
+    XCTAssertEqual(c.cS2RC("kl"), "ㄎㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("klj"), "ㄎㄥˇ")
+    XCTAssertEqual(c.cS2RC("klj"), "ㄎㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kx"), "ㄎㄨ")
+    XCTAssertEqual(c.cS2RC("kx"), "ㄎㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxf"), "ㄎㄨˊ")
+    XCTAssertEqual(c.cS2RC("kxf"), "ㄎㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxj"), "ㄎㄨˇ")
+    XCTAssertEqual(c.cS2RC("kxj"), "ㄎㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxk"), "ㄎㄨˋ")
+    XCTAssertEqual(c.cS2RC("kxk"), "ㄎㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxa"), "ㄎㄨㄚ")
+    XCTAssertEqual(c.cS2RC("kxa"), "ㄎㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxaj"), "ㄎㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("kxaj"), "ㄎㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxak"), "ㄎㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("kxak"), "ㄎㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxok"), "ㄎㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("kxok"), "ㄎㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxi"), "ㄎㄨㄞ")
+    XCTAssertEqual(c.cS2RC("kxi"), "ㄎㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxij"), "ㄎㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("kxij"), "ㄎㄨㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxik"), "ㄎㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("kxik"), "ㄎㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxq"), "ㄎㄨㄟ")
+    XCTAssertEqual(c.cS2RC("kxq"), "ㄎㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxqf"), "ㄎㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("kxqf"), "ㄎㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxqj"), "ㄎㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("kxqj"), "ㄎㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxqk"), "ㄎㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("kxqk"), "ㄎㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxm"), "ㄎㄨㄢ")
+    XCTAssertEqual(c.cS2RC("kxm"), "ㄎㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxmj"), "ㄎㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("kxmj"), "ㄎㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxmk"), "ㄎㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("kxmk"), "ㄎㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxn"), "ㄎㄨㄣ")
+    XCTAssertEqual(c.cS2RC("kxn"), "ㄎㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxnj"), "ㄎㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("kxnj"), "ㄎㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxnk"), "ㄎㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("kxnk"), "ㄎㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxt"), "ㄎㄨㄤ")
+    XCTAssertEqual(c.cS2RC("kxt"), "ㄎㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxtf"), "ㄎㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("kxtf"), "ㄎㄨㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxtj"), "ㄎㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("kxtj"), "ㄎㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxtk"), "ㄎㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("kxtk"), "ㄎㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxl"), "ㄎㄨㄥ")
+    XCTAssertEqual(c.cS2RC("kxl"), "ㄎㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxlj"), "ㄎㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("kxlj"), "ㄎㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxlk"), "ㄎㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("kxlk"), "ㄎㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ha"), "ㄏㄚ")
+    XCTAssertEqual(c.cS2RC("ha"), "ㄏㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("haf"), "ㄏㄚˊ")
+    XCTAssertEqual(c.cS2RC("haf"), "ㄏㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("haj"), "ㄏㄚˇ")
+    XCTAssertEqual(c.cS2RC("haj"), "ㄏㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hr"), "ㄏㄜ")
+    XCTAssertEqual(c.cS2RC("hr"), "ㄏㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hrf"), "ㄏㄜˊ")
+    XCTAssertEqual(c.cS2RC("hrf"), "ㄏㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hrj"), "ㄏㄜˇ")
+    XCTAssertEqual(c.cS2RC("hrj"), "ㄏㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hrk"), "ㄏㄜˋ")
+    XCTAssertEqual(c.cS2RC("hrk"), "ㄏㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hi"), "ㄏㄞ")
+    XCTAssertEqual(c.cS2RC("hi"), "ㄏㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hif"), "ㄏㄞˊ")
+    XCTAssertEqual(c.cS2RC("hif"), "ㄏㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hij"), "ㄏㄞˇ")
+    XCTAssertEqual(c.cS2RC("hij"), "ㄏㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hik"), "ㄏㄞˋ")
+    XCTAssertEqual(c.cS2RC("hik"), "ㄏㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hq"), "ㄏㄟ")
+    XCTAssertEqual(c.cS2RC("hq"), "ㄏㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hqj"), "ㄏㄟˇ")
+    XCTAssertEqual(c.cS2RC("hqj"), "ㄏㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hz"), "ㄏㄠ")
+    XCTAssertEqual(c.cS2RC("hz"), "ㄏㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hzf"), "ㄏㄠˊ")
+    XCTAssertEqual(c.cS2RC("hzf"), "ㄏㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hzj"), "ㄏㄠˇ")
+    XCTAssertEqual(c.cS2RC("hzj"), "ㄏㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hzk"), "ㄏㄠˋ")
+    XCTAssertEqual(c.cS2RC("hzk"), "ㄏㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hp"), "ㄏㄡ")
+    XCTAssertEqual(c.cS2RC("hp"), "ㄏㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hpf"), "ㄏㄡˊ")
+    XCTAssertEqual(c.cS2RC("hpf"), "ㄏㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hpj"), "ㄏㄡˇ")
+    XCTAssertEqual(c.cS2RC("hpj"), "ㄏㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hpk"), "ㄏㄡˋ")
+    XCTAssertEqual(c.cS2RC("hpk"), "ㄏㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hm"), "ㄏㄢ")
+    XCTAssertEqual(c.cS2RC("hm"), "ㄏㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hmf"), "ㄏㄢˊ")
+    XCTAssertEqual(c.cS2RC("hmf"), "ㄏㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hmj"), "ㄏㄢˇ")
+    XCTAssertEqual(c.cS2RC("hmj"), "ㄏㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hmk"), "ㄏㄢˋ")
+    XCTAssertEqual(c.cS2RC("hmk"), "ㄏㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hn"), "ㄏㄣ")
+    XCTAssertEqual(c.cS2RC("hn"), "ㄏㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hnf"), "ㄏㄣˊ")
+    XCTAssertEqual(c.cS2RC("hnf"), "ㄏㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hnj"), "ㄏㄣˇ")
+    XCTAssertEqual(c.cS2RC("hnj"), "ㄏㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hnk"), "ㄏㄣˋ")
+    XCTAssertEqual(c.cS2RC("hnk"), "ㄏㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ht"), "ㄏㄤ")
+    XCTAssertEqual(c.cS2RC("ht"), "ㄏㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("htf"), "ㄏㄤˊ")
+    XCTAssertEqual(c.cS2RC("htf"), "ㄏㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("htj"), "ㄏㄤˇ")
+    XCTAssertEqual(c.cS2RC("htj"), "ㄏㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("htk"), "ㄏㄤˋ")
+    XCTAssertEqual(c.cS2RC("htk"), "ㄏㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hl"), "ㄏㄥ")
+    XCTAssertEqual(c.cS2RC("hl"), "ㄏㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hlf"), "ㄏㄥˊ")
+    XCTAssertEqual(c.cS2RC("hlf"), "ㄏㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hlk"), "ㄏㄥˋ")
+    XCTAssertEqual(c.cS2RC("hlk"), "ㄏㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hx"), "ㄏㄨ")
+    XCTAssertEqual(c.cS2RC("hx"), "ㄏㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxf"), "ㄏㄨˊ")
+    XCTAssertEqual(c.cS2RC("hxf"), "ㄏㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxj"), "ㄏㄨˇ")
+    XCTAssertEqual(c.cS2RC("hxj"), "ㄏㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxk"), "ㄏㄨˋ")
+    XCTAssertEqual(c.cS2RC("hxk"), "ㄏㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxa"), "ㄏㄨㄚ")
+    XCTAssertEqual(c.cS2RC("hxa"), "ㄏㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxaf"), "ㄏㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("hxaf"), "ㄏㄨㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxaj"), "ㄏㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("hxaj"), "ㄏㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxak"), "ㄏㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("hxak"), "ㄏㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxo"), "ㄏㄨㄛ")
+    XCTAssertEqual(c.cS2RC("hxo"), "ㄏㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxof"), "ㄏㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("hxof"), "ㄏㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxoj"), "ㄏㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("hxoj"), "ㄏㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxok"), "ㄏㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("hxok"), "ㄏㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxod"), "ㄏㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("hxod"), "ㄏㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxif"), "ㄏㄨㄞˊ")
+    XCTAssertEqual(c.cS2RC("hxif"), "ㄏㄨㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxik"), "ㄏㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("hxik"), "ㄏㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxq"), "ㄏㄨㄟ")
+    XCTAssertEqual(c.cS2RC("hxq"), "ㄏㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxqf"), "ㄏㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("hxqf"), "ㄏㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxqj"), "ㄏㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("hxqj"), "ㄏㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxqk"), "ㄏㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("hxqk"), "ㄏㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxm"), "ㄏㄨㄢ")
+    XCTAssertEqual(c.cS2RC("hxm"), "ㄏㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxmf"), "ㄏㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("hxmf"), "ㄏㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxmj"), "ㄏㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("hxmj"), "ㄏㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxmk"), "ㄏㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("hxmk"), "ㄏㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxn"), "ㄏㄨㄣ")
+    XCTAssertEqual(c.cS2RC("hxn"), "ㄏㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxnf"), "ㄏㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("hxnf"), "ㄏㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxnj"), "ㄏㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("hxnj"), "ㄏㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxnk"), "ㄏㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("hxnk"), "ㄏㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxt"), "ㄏㄨㄤ")
+    XCTAssertEqual(c.cS2RC("hxt"), "ㄏㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxtf"), "ㄏㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("hxtf"), "ㄏㄨㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxtj"), "ㄏㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("hxtj"), "ㄏㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxtk"), "ㄏㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("hxtk"), "ㄏㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxtd"), "ㄏㄨㄤ˙")
+    XCTAssertEqual(c.cS2RC("hxtd"), "ㄏㄨㄤ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxl"), "ㄏㄨㄥ")
+    XCTAssertEqual(c.cS2RC("hxl"), "ㄏㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxlf"), "ㄏㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("hxlf"), "ㄏㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxlj"), "ㄏㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("hxlj"), "ㄏㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxlk"), "ㄏㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("hxlk"), "ㄏㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ge"), "ㄐㄧ")
+    XCTAssertEqual(c.cS2RC("ge"), "ㄐㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gef"), "ㄐㄧˊ")
+    XCTAssertEqual(c.cS2RC("gef"), "ㄐㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gej"), "ㄐㄧˇ")
+    XCTAssertEqual(c.cS2RC("gej"), "ㄐㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gek"), "ㄐㄧˋ")
+    XCTAssertEqual(c.cS2RC("gek"), "ㄐㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gea"), "ㄐㄧㄚ")
+    XCTAssertEqual(c.cS2RC("gea"), "ㄐㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("geaf"), "ㄐㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("geaf"), "ㄐㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("geaj"), "ㄐㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("geaj"), "ㄐㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("geak"), "ㄐㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("geak"), "ㄐㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gew"), "ㄐㄧㄝ")
+    XCTAssertEqual(c.cS2RC("gew"), "ㄐㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gewf"), "ㄐㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("gewf"), "ㄐㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gewj"), "ㄐㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("gewj"), "ㄐㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gewk"), "ㄐㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("gewk"), "ㄐㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gewd"), "ㄐㄧㄝ˙")
+    XCTAssertEqual(c.cS2RC("gewd"), "ㄐㄧㄝ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gez"), "ㄐㄧㄠ")
+    XCTAssertEqual(c.cS2RC("gez"), "ㄐㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gezf"), "ㄐㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("gezf"), "ㄐㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gezj"), "ㄐㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("gezj"), "ㄐㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gezk"), "ㄐㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("gezk"), "ㄐㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gep"), "ㄐㄧㄡ")
+    XCTAssertEqual(c.cS2RC("gep"), "ㄐㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gepj"), "ㄐㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("gepj"), "ㄐㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gepk"), "ㄐㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("gepk"), "ㄐㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gem"), "ㄐㄧㄢ")
+    XCTAssertEqual(c.cS2RC("gem"), "ㄐㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gemj"), "ㄐㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("gemj"), "ㄐㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gemk"), "ㄐㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("gemk"), "ㄐㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gen"), "ㄐㄧㄣ")
+    XCTAssertEqual(c.cS2RC("gen"), "ㄐㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("genj"), "ㄐㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("genj"), "ㄐㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("genk"), "ㄐㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("genk"), "ㄐㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("get"), "ㄐㄧㄤ")
+    XCTAssertEqual(c.cS2RC("get"), "ㄐㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("getf"), "ㄐㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("getf"), "ㄐㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("getj"), "ㄐㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("getj"), "ㄐㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("getk"), "ㄐㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("getk"), "ㄐㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gel"), "ㄐㄧㄥ")
+    XCTAssertEqual(c.cS2RC("gel"), "ㄐㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gelj"), "ㄐㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("gelj"), "ㄐㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gelk"), "ㄐㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("gelk"), "ㄐㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gu"), "ㄐㄩ")
+    XCTAssertEqual(c.cS2RC("gu"), "ㄐㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guf"), "ㄐㄩˊ")
+    XCTAssertEqual(c.cS2RC("guf"), "ㄐㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guj"), "ㄐㄩˇ")
+    XCTAssertEqual(c.cS2RC("guj"), "ㄐㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guk"), "ㄐㄩˋ")
+    XCTAssertEqual(c.cS2RC("guk"), "ㄐㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guw"), "ㄐㄩㄝ")
+    XCTAssertEqual(c.cS2RC("guw"), "ㄐㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guwf"), "ㄐㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("guwf"), "ㄐㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guwj"), "ㄐㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("guwj"), "ㄐㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guwk"), "ㄐㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("guwk"), "ㄐㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gum"), "ㄐㄩㄢ")
+    XCTAssertEqual(c.cS2RC("gum"), "ㄐㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gumj"), "ㄐㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("gumj"), "ㄐㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gumk"), "ㄐㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("gumk"), "ㄐㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gun"), "ㄐㄩㄣ")
+    XCTAssertEqual(c.cS2RC("gun"), "ㄐㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gunf"), "ㄐㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("gunf"), "ㄐㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gunj"), "ㄐㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("gunj"), "ㄐㄩㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gunk"), "ㄐㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("gunk"), "ㄐㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gul"), "ㄐㄩㄥ")
+    XCTAssertEqual(c.cS2RC("gul"), "ㄐㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gulj"), "ㄐㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("gulj"), "ㄐㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gulk"), "ㄐㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("gulk"), "ㄐㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vd"), "ㄑ˙")
+    XCTAssertEqual(c.cS2RC("vd"), "ㄑ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ve"), "ㄑㄧ")
+    XCTAssertEqual(c.cS2RC("ve"), "ㄑㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vef"), "ㄑㄧˊ")
+    XCTAssertEqual(c.cS2RC("vef"), "ㄑㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vej"), "ㄑㄧˇ")
+    XCTAssertEqual(c.cS2RC("vej"), "ㄑㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vek"), "ㄑㄧˋ")
+    XCTAssertEqual(c.cS2RC("vek"), "ㄑㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vea"), "ㄑㄧㄚ")
+    XCTAssertEqual(c.cS2RC("vea"), "ㄑㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veaf"), "ㄑㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("veaf"), "ㄑㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veaj"), "ㄑㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("veaj"), "ㄑㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veak"), "ㄑㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("veak"), "ㄑㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vew"), "ㄑㄧㄝ")
+    XCTAssertEqual(c.cS2RC("vew"), "ㄑㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vewf"), "ㄑㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("vewf"), "ㄑㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vewj"), "ㄑㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("vewj"), "ㄑㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vewk"), "ㄑㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("vewk"), "ㄑㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vez"), "ㄑㄧㄠ")
+    XCTAssertEqual(c.cS2RC("vez"), "ㄑㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vezf"), "ㄑㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("vezf"), "ㄑㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vezj"), "ㄑㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("vezj"), "ㄑㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vezk"), "ㄑㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("vezk"), "ㄑㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vep"), "ㄑㄧㄡ")
+    XCTAssertEqual(c.cS2RC("vep"), "ㄑㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vepf"), "ㄑㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("vepf"), "ㄑㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vepj"), "ㄑㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("vepj"), "ㄑㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vepk"), "ㄑㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("vepk"), "ㄑㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vem"), "ㄑㄧㄢ")
+    XCTAssertEqual(c.cS2RC("vem"), "ㄑㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vemf"), "ㄑㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("vemf"), "ㄑㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vemj"), "ㄑㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("vemj"), "ㄑㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vemk"), "ㄑㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("vemk"), "ㄑㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ven"), "ㄑㄧㄣ")
+    XCTAssertEqual(c.cS2RC("ven"), "ㄑㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("venf"), "ㄑㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("venf"), "ㄑㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("venj"), "ㄑㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("venj"), "ㄑㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("venk"), "ㄑㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("venk"), "ㄑㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vet"), "ㄑㄧㄤ")
+    XCTAssertEqual(c.cS2RC("vet"), "ㄑㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vetf"), "ㄑㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("vetf"), "ㄑㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vetj"), "ㄑㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("vetj"), "ㄑㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vetk"), "ㄑㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("vetk"), "ㄑㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vel"), "ㄑㄧㄥ")
+    XCTAssertEqual(c.cS2RC("vel"), "ㄑㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("velf"), "ㄑㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("velf"), "ㄑㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("velj"), "ㄑㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("velj"), "ㄑㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("velk"), "ㄑㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("velk"), "ㄑㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vu"), "ㄑㄩ")
+    XCTAssertEqual(c.cS2RC("vu"), "ㄑㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuf"), "ㄑㄩˊ")
+    XCTAssertEqual(c.cS2RC("vuf"), "ㄑㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuj"), "ㄑㄩˇ")
+    XCTAssertEqual(c.cS2RC("vuj"), "ㄑㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuk"), "ㄑㄩˋ")
+    XCTAssertEqual(c.cS2RC("vuk"), "ㄑㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuw"), "ㄑㄩㄝ")
+    XCTAssertEqual(c.cS2RC("vuw"), "ㄑㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuwf"), "ㄑㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("vuwf"), "ㄑㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuwk"), "ㄑㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("vuwk"), "ㄑㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vum"), "ㄑㄩㄢ")
+    XCTAssertEqual(c.cS2RC("vum"), "ㄑㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vumf"), "ㄑㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("vumf"), "ㄑㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vumj"), "ㄑㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("vumj"), "ㄑㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vumk"), "ㄑㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("vumk"), "ㄑㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vun"), "ㄑㄩㄣ")
+    XCTAssertEqual(c.cS2RC("vun"), "ㄑㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vunf"), "ㄑㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("vunf"), "ㄑㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vunj"), "ㄑㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("vunj"), "ㄑㄩㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vunk"), "ㄑㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("vunk"), "ㄑㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vul"), "ㄑㄩㄥ")
+    XCTAssertEqual(c.cS2RC("vul"), "ㄑㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vulf"), "ㄑㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("vulf"), "ㄑㄩㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vulj"), "ㄑㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("vulj"), "ㄑㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vulk"), "ㄑㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("vulk"), "ㄑㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ce"), "ㄒㄧ")
+    XCTAssertEqual(c.cS2RC("ce"), "ㄒㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cef"), "ㄒㄧˊ")
+    XCTAssertEqual(c.cS2RC("cef"), "ㄒㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cej"), "ㄒㄧˇ")
+    XCTAssertEqual(c.cS2RC("cej"), "ㄒㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cek"), "ㄒㄧˋ")
+    XCTAssertEqual(c.cS2RC("cek"), "ㄒㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cea"), "ㄒㄧㄚ")
+    XCTAssertEqual(c.cS2RC("cea"), "ㄒㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceaf"), "ㄒㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("ceaf"), "ㄒㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceaj"), "ㄒㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("ceaj"), "ㄒㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceak"), "ㄒㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("ceak"), "ㄒㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cew"), "ㄒㄧㄝ")
+    XCTAssertEqual(c.cS2RC("cew"), "ㄒㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cewf"), "ㄒㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("cewf"), "ㄒㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cewj"), "ㄒㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("cewj"), "ㄒㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cewk"), "ㄒㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("cewk"), "ㄒㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cez"), "ㄒㄧㄠ")
+    XCTAssertEqual(c.cS2RC("cez"), "ㄒㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cezf"), "ㄒㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("cezf"), "ㄒㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cezj"), "ㄒㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("cezj"), "ㄒㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cezk"), "ㄒㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("cezk"), "ㄒㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cep"), "ㄒㄧㄡ")
+    XCTAssertEqual(c.cS2RC("cep"), "ㄒㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cepf"), "ㄒㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("cepf"), "ㄒㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cepj"), "ㄒㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("cepj"), "ㄒㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cepk"), "ㄒㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("cepk"), "ㄒㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cem"), "ㄒㄧㄢ")
+    XCTAssertEqual(c.cS2RC("cem"), "ㄒㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cemf"), "ㄒㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("cemf"), "ㄒㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cemj"), "ㄒㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("cemj"), "ㄒㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cemk"), "ㄒㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("cemk"), "ㄒㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cen"), "ㄒㄧㄣ")
+    XCTAssertEqual(c.cS2RC("cen"), "ㄒㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cenf"), "ㄒㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("cenf"), "ㄒㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cenj"), "ㄒㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("cenj"), "ㄒㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cenk"), "ㄒㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("cenk"), "ㄒㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cet"), "ㄒㄧㄤ")
+    XCTAssertEqual(c.cS2RC("cet"), "ㄒㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cetf"), "ㄒㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("cetf"), "ㄒㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cetj"), "ㄒㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("cetj"), "ㄒㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cetk"), "ㄒㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("cetk"), "ㄒㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cel"), "ㄒㄧㄥ")
+    XCTAssertEqual(c.cS2RC("cel"), "ㄒㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("celf"), "ㄒㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("celf"), "ㄒㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("celj"), "ㄒㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("celj"), "ㄒㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("celk"), "ㄒㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("celk"), "ㄒㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cu"), "ㄒㄩ")
+    XCTAssertEqual(c.cS2RC("cu"), "ㄒㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuf"), "ㄒㄩˊ")
+    XCTAssertEqual(c.cS2RC("cuf"), "ㄒㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuj"), "ㄒㄩˇ")
+    XCTAssertEqual(c.cS2RC("cuj"), "ㄒㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuk"), "ㄒㄩˋ")
+    XCTAssertEqual(c.cS2RC("cuk"), "ㄒㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuw"), "ㄒㄩㄝ")
+    XCTAssertEqual(c.cS2RC("cuw"), "ㄒㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuwf"), "ㄒㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("cuwf"), "ㄒㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuwj"), "ㄒㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("cuwj"), "ㄒㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuwk"), "ㄒㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("cuwk"), "ㄒㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cum"), "ㄒㄩㄢ")
+    XCTAssertEqual(c.cS2RC("cum"), "ㄒㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cumf"), "ㄒㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("cumf"), "ㄒㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cumj"), "ㄒㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("cumj"), "ㄒㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cumk"), "ㄒㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("cumk"), "ㄒㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cun"), "ㄒㄩㄣ")
+    XCTAssertEqual(c.cS2RC("cun"), "ㄒㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cunf"), "ㄒㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("cunf"), "ㄒㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cunk"), "ㄒㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("cunk"), "ㄒㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cul"), "ㄒㄩㄥ")
+    XCTAssertEqual(c.cS2RC("cul"), "ㄒㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("culf"), "ㄒㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("culf"), "ㄒㄩㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("culj"), "ㄒㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("culj"), "ㄒㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("culk"), "ㄒㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("culk"), "ㄒㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("g"), "ㄓ")
+    XCTAssertEqual(c.cS2RC("g"), "ㄓ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gf"), "ㄓˊ")
+    XCTAssertEqual(c.cS2RC("gf"), "ㄓˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gj"), "ㄓˇ")
+    XCTAssertEqual(c.cS2RC("gj"), "ㄓˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gk"), "ㄓˋ")
+    XCTAssertEqual(c.cS2RC("gk"), "ㄓˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ga"), "ㄓㄚ")
+    XCTAssertEqual(c.cS2RC("ga"), "ㄓㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gaf"), "ㄓㄚˊ")
+    XCTAssertEqual(c.cS2RC("gaf"), "ㄓㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gaj"), "ㄓㄚˇ")
+    XCTAssertEqual(c.cS2RC("gaj"), "ㄓㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gak"), "ㄓㄚˋ")
+    XCTAssertEqual(c.cS2RC("gak"), "ㄓㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gr"), "ㄓㄜ")
+    XCTAssertEqual(c.cS2RC("gr"), "ㄓㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("grf"), "ㄓㄜˊ")
+    XCTAssertEqual(c.cS2RC("grf"), "ㄓㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("grj"), "ㄓㄜˇ")
+    XCTAssertEqual(c.cS2RC("grj"), "ㄓㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("grk"), "ㄓㄜˋ")
+    XCTAssertEqual(c.cS2RC("grk"), "ㄓㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("grd"), "ㄓㄜ˙")
+    XCTAssertEqual(c.cS2RC("grd"), "ㄓㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gi"), "ㄓㄞ")
+    XCTAssertEqual(c.cS2RC("gi"), "ㄓㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gif"), "ㄓㄞˊ")
+    XCTAssertEqual(c.cS2RC("gif"), "ㄓㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gij"), "ㄓㄞˇ")
+    XCTAssertEqual(c.cS2RC("gij"), "ㄓㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gik"), "ㄓㄞˋ")
+    XCTAssertEqual(c.cS2RC("gik"), "ㄓㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gqk"), "ㄓㄟˋ")
+    XCTAssertEqual(c.cS2RC("gqk"), "ㄓㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gz"), "ㄓㄠ")
+    XCTAssertEqual(c.cS2RC("gz"), "ㄓㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gzf"), "ㄓㄠˊ")
+    XCTAssertEqual(c.cS2RC("gzf"), "ㄓㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gzj"), "ㄓㄠˇ")
+    XCTAssertEqual(c.cS2RC("gzj"), "ㄓㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gzk"), "ㄓㄠˋ")
+    XCTAssertEqual(c.cS2RC("gzk"), "ㄓㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gp"), "ㄓㄡ")
+    XCTAssertEqual(c.cS2RC("gp"), "ㄓㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gpf"), "ㄓㄡˊ")
+    XCTAssertEqual(c.cS2RC("gpf"), "ㄓㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gpj"), "ㄓㄡˇ")
+    XCTAssertEqual(c.cS2RC("gpj"), "ㄓㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gpk"), "ㄓㄡˋ")
+    XCTAssertEqual(c.cS2RC("gpk"), "ㄓㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gm"), "ㄓㄢ")
+    XCTAssertEqual(c.cS2RC("gm"), "ㄓㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gmj"), "ㄓㄢˇ")
+    XCTAssertEqual(c.cS2RC("gmj"), "ㄓㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gmk"), "ㄓㄢˋ")
+    XCTAssertEqual(c.cS2RC("gmk"), "ㄓㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gn"), "ㄓㄣ")
+    XCTAssertEqual(c.cS2RC("gn"), "ㄓㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gnf"), "ㄓㄣˊ")
+    XCTAssertEqual(c.cS2RC("gnf"), "ㄓㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gnj"), "ㄓㄣˇ")
+    XCTAssertEqual(c.cS2RC("gnj"), "ㄓㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gnk"), "ㄓㄣˋ")
+    XCTAssertEqual(c.cS2RC("gnk"), "ㄓㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gt"), "ㄓㄤ")
+    XCTAssertEqual(c.cS2RC("gt"), "ㄓㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gtj"), "ㄓㄤˇ")
+    XCTAssertEqual(c.cS2RC("gtj"), "ㄓㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gtk"), "ㄓㄤˋ")
+    XCTAssertEqual(c.cS2RC("gtk"), "ㄓㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gl"), "ㄓㄥ")
+    XCTAssertEqual(c.cS2RC("gl"), "ㄓㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("glj"), "ㄓㄥˇ")
+    XCTAssertEqual(c.cS2RC("glj"), "ㄓㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("glk"), "ㄓㄥˋ")
+    XCTAssertEqual(c.cS2RC("glk"), "ㄓㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gx"), "ㄓㄨ")
+    XCTAssertEqual(c.cS2RC("gx"), "ㄓㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxf"), "ㄓㄨˊ")
+    XCTAssertEqual(c.cS2RC("gxf"), "ㄓㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxj"), "ㄓㄨˇ")
+    XCTAssertEqual(c.cS2RC("gxj"), "ㄓㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxk"), "ㄓㄨˋ")
+    XCTAssertEqual(c.cS2RC("gxk"), "ㄓㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxa"), "ㄓㄨㄚ")
+    XCTAssertEqual(c.cS2RC("gxa"), "ㄓㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxaj"), "ㄓㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("gxaj"), "ㄓㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxo"), "ㄓㄨㄛ")
+    XCTAssertEqual(c.cS2RC("gxo"), "ㄓㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxof"), "ㄓㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("gxof"), "ㄓㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxok"), "ㄓㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("gxok"), "ㄓㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxi"), "ㄓㄨㄞ")
+    XCTAssertEqual(c.cS2RC("gxi"), "ㄓㄨㄞ")
   }
 }

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_A.swift

@@ -11,490 +11,494 @@ import XCTest
 @testable import Tekkon
 
 extension TekkonTestsKeyboardArrangments {
+  func testHsuKeysTaigi() throws {
+    var c = Tekkon.Composer(arrange: .ofHsu)
+    XCTAssertEqual(c.cS2RC("kek"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("gewd"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("gen"), "ㄍㄧㄣ")
+  }
+
   func testHsuKeysA() throws {
-    var composer = Tekkon.Composer(arrange: .ofHsu)
+    var c = Tekkon.Composer(arrange: .ofHsu)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kek"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("bekd"), "ㄅㄧㄤˊ")
-    // XCTAssertEqual(composer.convertSequenceToRawComposition("vezf"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("bekj"), "ㄅㄧㄤˋ")
-    // XCTAssertEqual(composer.convertSequenceToRawComposition("gen"), "ㄍㄧㄣ")
+    XCTAssertEqual(c.cS2RC("dxk"), "ㄉㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bekd"), "ㄅㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("by"), "ㄅㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bekj"), "ㄅㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("byd"), "ㄅㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxk"), "ㄉㄨㄤ")
+    XCTAssertEqual(c.cS2RC("byf"), "ㄅㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("by"), "ㄅㄚ")
+    XCTAssertEqual(c.cS2RC("byj"), "ㄅㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("byd"), "ㄅㄚˊ")
+    XCTAssertEqual(c.cS2RC("bys"), "ㄅㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("byf"), "ㄅㄚˇ")
+    XCTAssertEqual(c.cS2RC("bh"), "ㄅㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("byj"), "ㄅㄚˋ")
+    XCTAssertEqual(c.cS2RC("bhd"), "ㄅㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bys"), "ㄅㄚ˙")
+    XCTAssertEqual(c.cS2RC("bhf"), "ㄅㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bh"), "ㄅㄛ")
+    XCTAssertEqual(c.cS2RC("bhj"), "ㄅㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bhd"), "ㄅㄛˊ")
+    XCTAssertEqual(c.cS2RC("bhs"), "ㄅㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bhf"), "ㄅㄛˇ")
+    XCTAssertEqual(c.cS2RC("bi"), "ㄅㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bhj"), "ㄅㄛˋ")
+    XCTAssertEqual(c.cS2RC("bid"), "ㄅㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bhs"), "ㄅㄛ˙")
+    XCTAssertEqual(c.cS2RC("bif"), "ㄅㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bi"), "ㄅㄞ")
+    XCTAssertEqual(c.cS2RC("bij"), "ㄅㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bid"), "ㄅㄞˊ")
+    XCTAssertEqual(c.cS2RC("bis"), "ㄅㄞ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bif"), "ㄅㄞˇ")
+    XCTAssertEqual(c.cS2RC("ba"), "ㄅㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bij"), "ㄅㄞˋ")
+    XCTAssertEqual(c.cS2RC("baf"), "ㄅㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bis"), "ㄅㄞ˙")
+    XCTAssertEqual(c.cS2RC("baj"), "ㄅㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ba"), "ㄅㄟ")
+    XCTAssertEqual(c.cS2RC("bas"), "ㄅㄟ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("baf"), "ㄅㄟˇ")
+    XCTAssertEqual(c.cS2RC("bw"), "ㄅㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("baj"), "ㄅㄟˋ")
+    XCTAssertEqual(c.cS2RC("bwd"), "ㄅㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bas"), "ㄅㄟ˙")
+    XCTAssertEqual(c.cS2RC("bwf"), "ㄅㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bw"), "ㄅㄠ")
+    XCTAssertEqual(c.cS2RC("bwj"), "ㄅㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bwd"), "ㄅㄠˊ")
+    XCTAssertEqual(c.cS2RC("bm"), "ㄅㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bwf"), "ㄅㄠˇ")
+    XCTAssertEqual(c.cS2RC("bmf"), "ㄅㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bwj"), "ㄅㄠˋ")
+    XCTAssertEqual(c.cS2RC("bmj"), "ㄅㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bm"), "ㄅㄢ")
+    XCTAssertEqual(c.cS2RC("bn"), "ㄅㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bmf"), "ㄅㄢˇ")
+    XCTAssertEqual(c.cS2RC("bnf"), "ㄅㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bmj"), "ㄅㄢˋ")
+    XCTAssertEqual(c.cS2RC("bnj"), "ㄅㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bn"), "ㄅㄣ")
+    XCTAssertEqual(c.cS2RC("bk"), "ㄅㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bnf"), "ㄅㄣˇ")
+    XCTAssertEqual(c.cS2RC("bkf"), "ㄅㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bnj"), "ㄅㄣˋ")
+    XCTAssertEqual(c.cS2RC("bkj"), "ㄅㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bk"), "ㄅㄤ")
+    XCTAssertEqual(c.cS2RC("bl"), "ㄅㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bkf"), "ㄅㄤˇ")
+    XCTAssertEqual(c.cS2RC("bld"), "ㄅㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bkj"), "ㄅㄤˋ")
+    XCTAssertEqual(c.cS2RC("blf"), "ㄅㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bl"), "ㄅㄥ")
+    XCTAssertEqual(c.cS2RC("blj"), "ㄅㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bld"), "ㄅㄥˊ")
+    XCTAssertEqual(c.cS2RC("be"), "ㄅㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("blf"), "ㄅㄥˇ")
+    XCTAssertEqual(c.cS2RC("bed"), "ㄅㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("blj"), "ㄅㄥˋ")
+    XCTAssertEqual(c.cS2RC("bef"), "ㄅㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("be"), "ㄅㄧ")
+    XCTAssertEqual(c.cS2RC("bej"), "ㄅㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bed"), "ㄅㄧˊ")
+    XCTAssertEqual(c.cS2RC("bee"), "ㄅㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bef"), "ㄅㄧˇ")
+    XCTAssertEqual(c.cS2RC("beed"), "ㄅㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bej"), "ㄅㄧˋ")
+    XCTAssertEqual(c.cS2RC("beef"), "ㄅㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bee"), "ㄅㄧㄝ")
+    XCTAssertEqual(c.cS2RC("beej"), "ㄅㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("beed"), "ㄅㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("bew"), "ㄅㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("beef"), "ㄅㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("bewf"), "ㄅㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("beej"), "ㄅㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("bewj"), "ㄅㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bew"), "ㄅㄧㄠ")
+    XCTAssertEqual(c.cS2RC("bem"), "ㄅㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bewf"), "ㄅㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("bemd"), "ㄅㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bewj"), "ㄅㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("bemf"), "ㄅㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bem"), "ㄅㄧㄢ")
+    XCTAssertEqual(c.cS2RC("bemj"), "ㄅㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bemd"), "ㄅㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("ben"), "ㄅㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bemf"), "ㄅㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("benf"), "ㄅㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bemj"), "ㄅㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("benj"), "ㄅㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ben"), "ㄅㄧㄣ")
+    XCTAssertEqual(c.cS2RC("bel"), "ㄅㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("benf"), "ㄅㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("belf"), "ㄅㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("benj"), "ㄅㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("belj"), "ㄅㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bel"), "ㄅㄧㄥ")
+    XCTAssertEqual(c.cS2RC("bx"), "ㄅㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("belf"), "ㄅㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("bxd"), "ㄅㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("belj"), "ㄅㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("bxf"), "ㄅㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bx"), "ㄅㄨ")
+    XCTAssertEqual(c.cS2RC("bxj"), "ㄅㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bxd"), "ㄅㄨˊ")
+    XCTAssertEqual(c.cS2RC("py"), "ㄆㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bxf"), "ㄅㄨˇ")
+    XCTAssertEqual(c.cS2RC("pyd"), "ㄆㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bxj"), "ㄅㄨˋ")
+    XCTAssertEqual(c.cS2RC("pyf"), "ㄆㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("py"), "ㄆㄚ")
+    XCTAssertEqual(c.cS2RC("pyj"), "ㄆㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pyd"), "ㄆㄚˊ")
+    XCTAssertEqual(c.cS2RC("pys"), "ㄆㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pyf"), "ㄆㄚˇ")
+    XCTAssertEqual(c.cS2RC("ph"), "ㄆㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pyj"), "ㄆㄚˋ")
+    XCTAssertEqual(c.cS2RC("phd"), "ㄆㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pys"), "ㄆㄚ˙")
+    XCTAssertEqual(c.cS2RC("phf"), "ㄆㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ph"), "ㄆㄛ")
+    XCTAssertEqual(c.cS2RC("phj"), "ㄆㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("phd"), "ㄆㄛˊ")
+    XCTAssertEqual(c.cS2RC("pi"), "ㄆㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("phf"), "ㄆㄛˇ")
+    XCTAssertEqual(c.cS2RC("pid"), "ㄆㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("phj"), "ㄆㄛˋ")
+    XCTAssertEqual(c.cS2RC("pif"), "ㄆㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pi"), "ㄆㄞ")
+    XCTAssertEqual(c.cS2RC("pij"), "ㄆㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pid"), "ㄆㄞˊ")
+    XCTAssertEqual(c.cS2RC("pa"), "ㄆㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pif"), "ㄆㄞˇ")
+    XCTAssertEqual(c.cS2RC("pad"), "ㄆㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pij"), "ㄆㄞˋ")
+    XCTAssertEqual(c.cS2RC("paf"), "ㄆㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pa"), "ㄆㄟ")
+    XCTAssertEqual(c.cS2RC("paj"), "ㄆㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pad"), "ㄆㄟˊ")
+    XCTAssertEqual(c.cS2RC("pw"), "ㄆㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("paf"), "ㄆㄟˇ")
+    XCTAssertEqual(c.cS2RC("pwd"), "ㄆㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("paj"), "ㄆㄟˋ")
+    XCTAssertEqual(c.cS2RC("pwf"), "ㄆㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pw"), "ㄆㄠ")
+    XCTAssertEqual(c.cS2RC("pwj"), "ㄆㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pwd"), "ㄆㄠˊ")
+    XCTAssertEqual(c.cS2RC("po"), "ㄆㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pwf"), "ㄆㄠˇ")
+    XCTAssertEqual(c.cS2RC("pod"), "ㄆㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pwj"), "ㄆㄠˋ")
+    XCTAssertEqual(c.cS2RC("pof"), "ㄆㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("po"), "ㄆㄡ")
+    XCTAssertEqual(c.cS2RC("poj"), "ㄆㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pod"), "ㄆㄡˊ")
+    XCTAssertEqual(c.cS2RC("pm"), "ㄆㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pof"), "ㄆㄡˇ")
+    XCTAssertEqual(c.cS2RC("pmd"), "ㄆㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("poj"), "ㄆㄡˋ")
+    XCTAssertEqual(c.cS2RC("pmf"), "ㄆㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pm"), "ㄆㄢ")
+    XCTAssertEqual(c.cS2RC("pmj"), "ㄆㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pmd"), "ㄆㄢˊ")
+    XCTAssertEqual(c.cS2RC("pn"), "ㄆㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pmf"), "ㄆㄢˇ")
+    XCTAssertEqual(c.cS2RC("pnd"), "ㄆㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pmj"), "ㄆㄢˋ")
+    XCTAssertEqual(c.cS2RC("pnf"), "ㄆㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pn"), "ㄆㄣ")
+    XCTAssertEqual(c.cS2RC("pnj"), "ㄆㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pnd"), "ㄆㄣˊ")
+    XCTAssertEqual(c.cS2RC("pk"), "ㄆㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pnf"), "ㄆㄣˇ")
+    XCTAssertEqual(c.cS2RC("pkd"), "ㄆㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pnj"), "ㄆㄣˋ")
+    XCTAssertEqual(c.cS2RC("pkf"), "ㄆㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pk"), "ㄆㄤ")
+    XCTAssertEqual(c.cS2RC("pkj"), "ㄆㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pkd"), "ㄆㄤˊ")
+    XCTAssertEqual(c.cS2RC("pl"), "ㄆㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pkf"), "ㄆㄤˇ")
+    XCTAssertEqual(c.cS2RC("pld"), "ㄆㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pkj"), "ㄆㄤˋ")
+    XCTAssertEqual(c.cS2RC("plf"), "ㄆㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pl"), "ㄆㄥ")
+    XCTAssertEqual(c.cS2RC("plj"), "ㄆㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pld"), "ㄆㄥˊ")
+    XCTAssertEqual(c.cS2RC("pe"), "ㄆㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("plf"), "ㄆㄥˇ")
+    XCTAssertEqual(c.cS2RC("ped"), "ㄆㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("plj"), "ㄆㄥˋ")
+    XCTAssertEqual(c.cS2RC("pef"), "ㄆㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pe"), "ㄆㄧ")
+    XCTAssertEqual(c.cS2RC("pej"), "ㄆㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ped"), "ㄆㄧˊ")
+    XCTAssertEqual(c.cS2RC("pey"), "ㄆㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pef"), "ㄆㄧˇ")
+    XCTAssertEqual(c.cS2RC("pee"), "ㄆㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pej"), "ㄆㄧˋ")
+    XCTAssertEqual(c.cS2RC("peef"), "ㄆㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pey"), "ㄆㄧㄚ")
+    XCTAssertEqual(c.cS2RC("peej"), "ㄆㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pee"), "ㄆㄧㄝ")
+    XCTAssertEqual(c.cS2RC("pew"), "ㄆㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("peef"), "ㄆㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("pewd"), "ㄆㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("peej"), "ㄆㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("pewf"), "ㄆㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pew"), "ㄆㄧㄠ")
+    XCTAssertEqual(c.cS2RC("pewj"), "ㄆㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pewd"), "ㄆㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("pem"), "ㄆㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pewf"), "ㄆㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("pemd"), "ㄆㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pewj"), "ㄆㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("pemf"), "ㄆㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pem"), "ㄆㄧㄢ")
+    XCTAssertEqual(c.cS2RC("pemj"), "ㄆㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pemd"), "ㄆㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("pen"), "ㄆㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pemf"), "ㄆㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("pend"), "ㄆㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pemj"), "ㄆㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("penf"), "ㄆㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pen"), "ㄆㄧㄣ")
+    XCTAssertEqual(c.cS2RC("penj"), "ㄆㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pend"), "ㄆㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("pel"), "ㄆㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("penf"), "ㄆㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("peld"), "ㄆㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("penj"), "ㄆㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("pelf"), "ㄆㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pel"), "ㄆㄧㄥ")
+    XCTAssertEqual(c.cS2RC("pelj"), "ㄆㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("peld"), "ㄆㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("px"), "ㄆㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pelf"), "ㄆㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("pxd"), "ㄆㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pelj"), "ㄆㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("pxf"), "ㄆㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("px"), "ㄆㄨ")
+    XCTAssertEqual(c.cS2RC("pxj"), "ㄆㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pxd"), "ㄆㄨˊ")
+    XCTAssertEqual(c.cS2RC("my"), "ㄇㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pxf"), "ㄆㄨˇ")
+    XCTAssertEqual(c.cS2RC("myd"), "ㄇㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pxj"), "ㄆㄨˋ")
+    XCTAssertEqual(c.cS2RC("myf"), "ㄇㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("my"), "ㄇㄚ")
+    XCTAssertEqual(c.cS2RC("myj"), "ㄇㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("myd"), "ㄇㄚˊ")
+    XCTAssertEqual(c.cS2RC("mys"), "ㄇㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("myf"), "ㄇㄚˇ")
+    XCTAssertEqual(c.cS2RC("mh"), "ㄇㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("myj"), "ㄇㄚˋ")
+    XCTAssertEqual(c.cS2RC("mhd"), "ㄇㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mys"), "ㄇㄚ˙")
+    XCTAssertEqual(c.cS2RC("mhf"), "ㄇㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mh"), "ㄇㄛ")
+    XCTAssertEqual(c.cS2RC("mhj"), "ㄇㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mhd"), "ㄇㄛˊ")
+    XCTAssertEqual(c.cS2RC("mhs"), "ㄇㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mhf"), "ㄇㄛˇ")
+    XCTAssertEqual(c.cS2RC("mg"), "ㄇㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mhj"), "ㄇㄛˋ")
+    XCTAssertEqual(c.cS2RC("mgj"), "ㄇㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mhs"), "ㄇㄛ˙")
+    XCTAssertEqual(c.cS2RC("mgs"), "ㄇㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mg"), "ㄇㄜ")
+    XCTAssertEqual(c.cS2RC("mi"), "ㄇㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mgj"), "ㄇㄜˋ")
+    XCTAssertEqual(c.cS2RC("mid"), "ㄇㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mgs"), "ㄇㄜ˙")
+    XCTAssertEqual(c.cS2RC("mif"), "ㄇㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mi"), "ㄇㄞ")
+    XCTAssertEqual(c.cS2RC("mij"), "ㄇㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mid"), "ㄇㄞˊ")
+    XCTAssertEqual(c.cS2RC("mad"), "ㄇㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mif"), "ㄇㄞˇ")
+    XCTAssertEqual(c.cS2RC("maf"), "ㄇㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mij"), "ㄇㄞˋ")
+    XCTAssertEqual(c.cS2RC("maj"), "ㄇㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mad"), "ㄇㄟˊ")
+    XCTAssertEqual(c.cS2RC("mw"), "ㄇㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("maf"), "ㄇㄟˇ")
+    XCTAssertEqual(c.cS2RC("mwd"), "ㄇㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("maj"), "ㄇㄟˋ")
+    XCTAssertEqual(c.cS2RC("mwf"), "ㄇㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mw"), "ㄇㄠ")
+    XCTAssertEqual(c.cS2RC("mwj"), "ㄇㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mwd"), "ㄇㄠˊ")
+    XCTAssertEqual(c.cS2RC("mod"), "ㄇㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mwf"), "ㄇㄠˇ")
+    XCTAssertEqual(c.cS2RC("mof"), "ㄇㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mwj"), "ㄇㄠˋ")
+    XCTAssertEqual(c.cS2RC("moj"), "ㄇㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mod"), "ㄇㄡˊ")
+    XCTAssertEqual(c.cS2RC("mm"), "ㄇㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mof"), "ㄇㄡˇ")
+    XCTAssertEqual(c.cS2RC("mmd"), "ㄇㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("moj"), "ㄇㄡˋ")
+    XCTAssertEqual(c.cS2RC("mmf"), "ㄇㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mm"), "ㄇㄢ")
+    XCTAssertEqual(c.cS2RC("mmj"), "ㄇㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mmd"), "ㄇㄢˊ")
+    XCTAssertEqual(c.cS2RC("mn"), "ㄇㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mmf"), "ㄇㄢˇ")
+    XCTAssertEqual(c.cS2RC("mnd"), "ㄇㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mmj"), "ㄇㄢˋ")
+    XCTAssertEqual(c.cS2RC("mnf"), "ㄇㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mn"), "ㄇㄣ")
+    XCTAssertEqual(c.cS2RC("mnj"), "ㄇㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mnd"), "ㄇㄣˊ")
+    XCTAssertEqual(c.cS2RC("mns"), "ㄇㄣ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mnf"), "ㄇㄣˇ")
+    XCTAssertEqual(c.cS2RC("mk"), "ㄇㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mnj"), "ㄇㄣˋ")
+    XCTAssertEqual(c.cS2RC("mkd"), "ㄇㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mns"), "ㄇㄣ˙")
+    XCTAssertEqual(c.cS2RC("mkf"), "ㄇㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mk"), "ㄇㄤ")
+    XCTAssertEqual(c.cS2RC("mkj"), "ㄇㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mkd"), "ㄇㄤˊ")
+    XCTAssertEqual(c.cS2RC("ml"), "ㄇㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mkf"), "ㄇㄤˇ")
+    XCTAssertEqual(c.cS2RC("mld"), "ㄇㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mkj"), "ㄇㄤˋ")
+    XCTAssertEqual(c.cS2RC("mlf"), "ㄇㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ml"), "ㄇㄥ")
+    XCTAssertEqual(c.cS2RC("mlj"), "ㄇㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mld"), "ㄇㄥˊ")
+    XCTAssertEqual(c.cS2RC("me"), "ㄇㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mlf"), "ㄇㄥˇ")
+    XCTAssertEqual(c.cS2RC("med"), "ㄇㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mlj"), "ㄇㄥˋ")
+    XCTAssertEqual(c.cS2RC("mef"), "ㄇㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("me"), "ㄇㄧ")
+    XCTAssertEqual(c.cS2RC("mej"), "ㄇㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("med"), "ㄇㄧˊ")
+    XCTAssertEqual(c.cS2RC("mee"), "ㄇㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mef"), "ㄇㄧˇ")
+    XCTAssertEqual(c.cS2RC("meed"), "ㄇㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mej"), "ㄇㄧˋ")
+    XCTAssertEqual(c.cS2RC("meej"), "ㄇㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mee"), "ㄇㄧㄝ")
+    XCTAssertEqual(c.cS2RC("mew"), "ㄇㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("meed"), "ㄇㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("mewd"), "ㄇㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("meej"), "ㄇㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("mewf"), "ㄇㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mew"), "ㄇㄧㄠ")
+    XCTAssertEqual(c.cS2RC("mewj"), "ㄇㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mewd"), "ㄇㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("meod"), "ㄇㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mewf"), "ㄇㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("meof"), "ㄇㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mewj"), "ㄇㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("meoj"), "ㄇㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("meod"), "ㄇㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("mem"), "ㄇㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("meof"), "ㄇㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("memd"), "ㄇㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("meoj"), "ㄇㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("memf"), "ㄇㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mem"), "ㄇㄧㄢ")
+    XCTAssertEqual(c.cS2RC("memj"), "ㄇㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("memd"), "ㄇㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("men"), "ㄇㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("memf"), "ㄇㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("mend"), "ㄇㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("memj"), "ㄇㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("menf"), "ㄇㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("men"), "ㄇㄧㄣ")
+    XCTAssertEqual(c.cS2RC("meld"), "ㄇㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mend"), "ㄇㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("melf"), "ㄇㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("menf"), "ㄇㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("melj"), "ㄇㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("meld"), "ㄇㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("mxd"), "ㄇㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("melf"), "ㄇㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("mxf"), "ㄇㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("melj"), "ㄇㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("mxj"), "ㄇㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mxd"), "ㄇㄨˊ")
+    XCTAssertEqual(c.cS2RC("fy"), "ㄈㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mxf"), "ㄇㄨˇ")
+    XCTAssertEqual(c.cS2RC("fyd"), "ㄈㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mxj"), "ㄇㄨˋ")
+    XCTAssertEqual(c.cS2RC("fyf"), "ㄈㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fy"), "ㄈㄚ")
+    XCTAssertEqual(c.cS2RC("fyj"), "ㄈㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fyd"), "ㄈㄚˊ")
+    XCTAssertEqual(c.cS2RC("fhd"), "ㄈㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fyf"), "ㄈㄚˇ")
+    XCTAssertEqual(c.cS2RC("fa"), "ㄈㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fyj"), "ㄈㄚˋ")
+    XCTAssertEqual(c.cS2RC("fad"), "ㄈㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fhd"), "ㄈㄛˊ")
+    XCTAssertEqual(c.cS2RC("faf"), "ㄈㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fa"), "ㄈㄟ")
+    XCTAssertEqual(c.cS2RC("faj"), "ㄈㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fad"), "ㄈㄟˊ")
+    XCTAssertEqual(c.cS2RC("fo"), "ㄈㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("faf"), "ㄈㄟˇ")
+    XCTAssertEqual(c.cS2RC("fod"), "ㄈㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("faj"), "ㄈㄟˋ")
+    XCTAssertEqual(c.cS2RC("fof"), "ㄈㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fo"), "ㄈㄡ")
+    XCTAssertEqual(c.cS2RC("foj"), "ㄈㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fod"), "ㄈㄡˊ")
+    XCTAssertEqual(c.cS2RC("fm"), "ㄈㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fof"), "ㄈㄡˇ")
+    XCTAssertEqual(c.cS2RC("fmd"), "ㄈㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("foj"), "ㄈㄡˋ")
+    XCTAssertEqual(c.cS2RC("fmf"), "ㄈㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fm"), "ㄈㄢ")
+    XCTAssertEqual(c.cS2RC("fmj"), "ㄈㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmd"), "ㄈㄢˊ")
+    XCTAssertEqual(c.cS2RC("fn"), "ㄈㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmf"), "ㄈㄢˇ")
+    XCTAssertEqual(c.cS2RC("fnd"), "ㄈㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fmj"), "ㄈㄢˋ")
+    XCTAssertEqual(c.cS2RC("fnf"), "ㄈㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fn"), "ㄈㄣ")
+    XCTAssertEqual(c.cS2RC("fnj"), "ㄈㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fnd"), "ㄈㄣˊ")
+    XCTAssertEqual(c.cS2RC("fns"), "ㄈㄣ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fnf"), "ㄈㄣˇ")
+    XCTAssertEqual(c.cS2RC("fk"), "ㄈㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fnj"), "ㄈㄣˋ")
+    XCTAssertEqual(c.cS2RC("fkd"), "ㄈㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fns"), "ㄈㄣ˙")
+    XCTAssertEqual(c.cS2RC("fkf"), "ㄈㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fk"), "ㄈㄤ")
+    XCTAssertEqual(c.cS2RC("fkj"), "ㄈㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fkd"), "ㄈㄤˊ")
+    XCTAssertEqual(c.cS2RC("fl"), "ㄈㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fkf"), "ㄈㄤˇ")
+    XCTAssertEqual(c.cS2RC("fld"), "ㄈㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fkj"), "ㄈㄤˋ")
+    XCTAssertEqual(c.cS2RC("flf"), "ㄈㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fl"), "ㄈㄥ")
+    XCTAssertEqual(c.cS2RC("flj"), "ㄈㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fld"), "ㄈㄥˊ")
+    XCTAssertEqual(c.cS2RC("fewj"), "ㄈㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("flf"), "ㄈㄥˇ")
+    XCTAssertEqual(c.cS2RC("fx"), "ㄈㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("flj"), "ㄈㄥˋ")
+    XCTAssertEqual(c.cS2RC("fxd"), "ㄈㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fewj"), "ㄈㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("fxf"), "ㄈㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fx"), "ㄈㄨ")
+    XCTAssertEqual(c.cS2RC("fxj"), "ㄈㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fxd"), "ㄈㄨˊ")
+    XCTAssertEqual(c.cS2RC("dy"), "ㄉㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fxf"), "ㄈㄨˇ")
+    XCTAssertEqual(c.cS2RC("dyd"), "ㄉㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fxj"), "ㄈㄨˋ")
+    XCTAssertEqual(c.cS2RC("dyf"), "ㄉㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dy"), "ㄉㄚ")
+    XCTAssertEqual(c.cS2RC("dyj"), "ㄉㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dyd"), "ㄉㄚˊ")
+    XCTAssertEqual(c.cS2RC("dys"), "ㄉㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dyf"), "ㄉㄚˇ")
+    XCTAssertEqual(c.cS2RC("dg"), "ㄉㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dyj"), "ㄉㄚˋ")
+    XCTAssertEqual(c.cS2RC("dgd"), "ㄉㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dys"), "ㄉㄚ˙")
+    XCTAssertEqual(c.cS2RC("dgs"), "ㄉㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dg"), "ㄉㄜ")
+    XCTAssertEqual(c.cS2RC("di"), "ㄉㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dgd"), "ㄉㄜˊ")
+    XCTAssertEqual(c.cS2RC("dif"), "ㄉㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dgs"), "ㄉㄜ˙")
+    XCTAssertEqual(c.cS2RC("dij"), "ㄉㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("di"), "ㄉㄞ")
+    XCTAssertEqual(c.cS2RC("daf"), "ㄉㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dif"), "ㄉㄞˇ")
+    XCTAssertEqual(c.cS2RC("dw"), "ㄉㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dij"), "ㄉㄞˋ")
+    XCTAssertEqual(c.cS2RC("dwd"), "ㄉㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("daf"), "ㄉㄟˇ")
+    XCTAssertEqual(c.cS2RC("dwf"), "ㄉㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dw"), "ㄉㄠ")
+    XCTAssertEqual(c.cS2RC("dwj"), "ㄉㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dwd"), "ㄉㄠˊ")
+    XCTAssertEqual(c.cS2RC("do"), "ㄉㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dwf"), "ㄉㄠˇ")
+    XCTAssertEqual(c.cS2RC("dod"), "ㄉㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dwj"), "ㄉㄠˋ")
+    XCTAssertEqual(c.cS2RC("dof"), "ㄉㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("do"), "ㄉㄡ")
+    XCTAssertEqual(c.cS2RC("doj"), "ㄉㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dod"), "ㄉㄡˊ")
+    XCTAssertEqual(c.cS2RC("dm"), "ㄉㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dof"), "ㄉㄡˇ")
+    XCTAssertEqual(c.cS2RC("dmf"), "ㄉㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("doj"), "ㄉㄡˋ")
+    XCTAssertEqual(c.cS2RC("dmj"), "ㄉㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dm"), "ㄉㄢ")
+    XCTAssertEqual(c.cS2RC("dnj"), "ㄉㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dmf"), "ㄉㄢˇ")
+    XCTAssertEqual(c.cS2RC("dk"), "ㄉㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dmj"), "ㄉㄢˋ")
+    XCTAssertEqual(c.cS2RC("dkf"), "ㄉㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dnj"), "ㄉㄣˋ")
+    XCTAssertEqual(c.cS2RC("dkj"), "ㄉㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dk"), "ㄉㄤ")
+    XCTAssertEqual(c.cS2RC("dl"), "ㄉㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dkf"), "ㄉㄤˇ")
+    XCTAssertEqual(c.cS2RC("dlf"), "ㄉㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dkj"), "ㄉㄤˋ")
+    XCTAssertEqual(c.cS2RC("dlj"), "ㄉㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dl"), "ㄉㄥ")
+    XCTAssertEqual(c.cS2RC("de"), "ㄉㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dlf"), "ㄉㄥˇ")
+    XCTAssertEqual(c.cS2RC("ded"), "ㄉㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dlj"), "ㄉㄥˋ")
+    XCTAssertEqual(c.cS2RC("def"), "ㄉㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("de"), "ㄉㄧ")
+    XCTAssertEqual(c.cS2RC("dej"), "ㄉㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ded"), "ㄉㄧˊ")
+    XCTAssertEqual(c.cS2RC("deyf"), "ㄉㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("def"), "ㄉㄧˇ")
+    XCTAssertEqual(c.cS2RC("dee"), "ㄉㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dej"), "ㄉㄧˋ")
+    XCTAssertEqual(c.cS2RC("deed"), "ㄉㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("deyf"), "ㄉㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("deef"), "ㄉㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dee"), "ㄉㄧㄝ")
+    XCTAssertEqual(c.cS2RC("deej"), "ㄉㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("deed"), "ㄉㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("dew"), "ㄉㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("deef"), "ㄉㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("dewf"), "ㄉㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("deej"), "ㄉㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("dewj"), "ㄉㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dew"), "ㄉㄧㄠ")
+    XCTAssertEqual(c.cS2RC("deo"), "ㄉㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dewf"), "ㄉㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("dem"), "ㄉㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dewj"), "ㄉㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("demd"), "ㄉㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("deo"), "ㄉㄧㄡ")
+    XCTAssertEqual(c.cS2RC("demf"), "ㄉㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dem"), "ㄉㄧㄢ")
+    XCTAssertEqual(c.cS2RC("demj"), "ㄉㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("demd"), "ㄉㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("del"), "ㄉㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("demf"), "ㄉㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("deld"), "ㄉㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("demj"), "ㄉㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("delf"), "ㄉㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("del"), "ㄉㄧㄥ")
+    XCTAssertEqual(c.cS2RC("delj"), "ㄉㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("deld"), "ㄉㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("dx"), "ㄉㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("delf"), "ㄉㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("dxd"), "ㄉㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("delj"), "ㄉㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("dxf"), "ㄉㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dx"), "ㄉㄨ")
+    XCTAssertEqual(c.cS2RC("dxj"), "ㄉㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxd"), "ㄉㄨˊ")
+    XCTAssertEqual(c.cS2RC("dxh"), "ㄉㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxf"), "ㄉㄨˇ")
+    XCTAssertEqual(c.cS2RC("dxhd"), "ㄉㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxj"), "ㄉㄨˋ")
+    XCTAssertEqual(c.cS2RC("dxhf"), "ㄉㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxh"), "ㄉㄨㄛ")
+    XCTAssertEqual(c.cS2RC("dxhj"), "ㄉㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxhd"), "ㄉㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("dxhs"), "ㄉㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxhf"), "ㄉㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("dxa"), "ㄉㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxhj"), "ㄉㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("dxaf"), "ㄉㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxhs"), "ㄉㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("dxaj"), "ㄉㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxa"), "ㄉㄨㄟ")
+    XCTAssertEqual(c.cS2RC("dxm"), "ㄉㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxaf"), "ㄉㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("dxmf"), "ㄉㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxaj"), "ㄉㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("dxmj"), "ㄉㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxm"), "ㄉㄨㄢ")
+    XCTAssertEqual(c.cS2RC("dxn"), "ㄉㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxmf"), "ㄉㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("dxnf"), "ㄉㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxmj"), "ㄉㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("dxnj"), "ㄉㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxn"), "ㄉㄨㄣ")
+    XCTAssertEqual(c.cS2RC("dxl"), "ㄉㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxnf"), "ㄉㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("dxlf"), "ㄉㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxnj"), "ㄉㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("dxlj"), "ㄉㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxl"), "ㄉㄨㄥ")
+    XCTAssertEqual(c.cS2RC("ty"), "ㄊㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxlf"), "ㄉㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("tyf"), "ㄊㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dxlj"), "ㄉㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("tyj"), "ㄊㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ty"), "ㄊㄚ")
+    XCTAssertEqual(c.cS2RC("tgj"), "ㄊㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tyf"), "ㄊㄚˇ")
+    XCTAssertEqual(c.cS2RC("ti"), "ㄊㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tyj"), "ㄊㄚˋ")
+    XCTAssertEqual(c.cS2RC("tid"), "ㄊㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tgj"), "ㄊㄜˋ")
+    XCTAssertEqual(c.cS2RC("tif"), "ㄊㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ti"), "ㄊㄞ")
+    XCTAssertEqual(c.cS2RC("tij"), "ㄊㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tid"), "ㄊㄞˊ")
+    XCTAssertEqual(c.cS2RC("tis"), "ㄊㄞ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tif"), "ㄊㄞˇ")
+    XCTAssertEqual(c.cS2RC("tw"), "ㄊㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tij"), "ㄊㄞˋ")
+    XCTAssertEqual(c.cS2RC("twd"), "ㄊㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tis"), "ㄊㄞ˙")
+    XCTAssertEqual(c.cS2RC("twf"), "ㄊㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tw"), "ㄊㄠ")
+    XCTAssertEqual(c.cS2RC("twj"), "ㄊㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("twd"), "ㄊㄠˊ")
+    XCTAssertEqual(c.cS2RC("tws"), "ㄊㄠ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("twf"), "ㄊㄠˇ")
+    XCTAssertEqual(c.cS2RC("to"), "ㄊㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("twj"), "ㄊㄠˋ")
+    XCTAssertEqual(c.cS2RC("tod"), "ㄊㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tws"), "ㄊㄠ˙")
+    XCTAssertEqual(c.cS2RC("tof"), "ㄊㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("to"), "ㄊㄡ")
+    XCTAssertEqual(c.cS2RC("toj"), "ㄊㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tod"), "ㄊㄡˊ")
+    XCTAssertEqual(c.cS2RC("tos"), "ㄊㄡ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tof"), "ㄊㄡˇ")
+    XCTAssertEqual(c.cS2RC("tm"), "ㄊㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("toj"), "ㄊㄡˋ")
+    XCTAssertEqual(c.cS2RC("tmd"), "ㄊㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tos"), "ㄊㄡ˙")
+    XCTAssertEqual(c.cS2RC("tmf"), "ㄊㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tm"), "ㄊㄢ")
+    XCTAssertEqual(c.cS2RC("tmj"), "ㄊㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tmd"), "ㄊㄢˊ")
+    XCTAssertEqual(c.cS2RC("tk"), "ㄊㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tmf"), "ㄊㄢˇ")
+    XCTAssertEqual(c.cS2RC("tkd"), "ㄊㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tmj"), "ㄊㄢˋ")
+    XCTAssertEqual(c.cS2RC("tkf"), "ㄊㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tk"), "ㄊㄤ")
+    XCTAssertEqual(c.cS2RC("tkj"), "ㄊㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tkd"), "ㄊㄤˊ")
+    XCTAssertEqual(c.cS2RC("tl"), "ㄊㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tkf"), "ㄊㄤˇ")
+    XCTAssertEqual(c.cS2RC("tld"), "ㄊㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tkj"), "ㄊㄤˋ")
+    XCTAssertEqual(c.cS2RC("tlj"), "ㄊㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tl"), "ㄊㄥ")
+    XCTAssertEqual(c.cS2RC("te"), "ㄊㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tld"), "ㄊㄥˊ")
+    XCTAssertEqual(c.cS2RC("ted"), "ㄊㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tlj"), "ㄊㄥˋ")
+    XCTAssertEqual(c.cS2RC("tef"), "ㄊㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("te"), "ㄊㄧ")
+    XCTAssertEqual(c.cS2RC("tej"), "ㄊㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ted"), "ㄊㄧˊ")
+    XCTAssertEqual(c.cS2RC("tee"), "ㄊㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tef"), "ㄊㄧˇ")
+    XCTAssertEqual(c.cS2RC("teed"), "ㄊㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tej"), "ㄊㄧˋ")
+    XCTAssertEqual(c.cS2RC("teef"), "ㄊㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tee"), "ㄊㄧㄝ")
+    XCTAssertEqual(c.cS2RC("teej"), "ㄊㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("teed"), "ㄊㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("tew"), "ㄊㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("teef"), "ㄊㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("tewd"), "ㄊㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("teej"), "ㄊㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("tewf"), "ㄊㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tew"), "ㄊㄧㄠ")
+    XCTAssertEqual(c.cS2RC("tewj"), "ㄊㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tewd"), "ㄊㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("tem"), "ㄊㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tewf"), "ㄊㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("temd"), "ㄊㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tewj"), "ㄊㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("temf"), "ㄊㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tem"), "ㄊㄧㄢ")
+    XCTAssertEqual(c.cS2RC("temj"), "ㄊㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("temd"), "ㄊㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("tel"), "ㄊㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("temf"), "ㄊㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("teld"), "ㄊㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("temj"), "ㄊㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("telf"), "ㄊㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tel"), "ㄊㄧㄥ")
+    XCTAssertEqual(c.cS2RC("telj"), "ㄊㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("teld"), "ㄊㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("tx"), "ㄊㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("telf"), "ㄊㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("txd"), "ㄊㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("telj"), "ㄊㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("txf"), "ㄊㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tx"), "ㄊㄨ")
+    XCTAssertEqual(c.cS2RC("txj"), "ㄊㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txd"), "ㄊㄨˊ")
+    XCTAssertEqual(c.cS2RC("txh"), "ㄊㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txf"), "ㄊㄨˇ")
+    XCTAssertEqual(c.cS2RC("txhd"), "ㄊㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txj"), "ㄊㄨˋ")
+    XCTAssertEqual(c.cS2RC("txhf"), "ㄊㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txh"), "ㄊㄨㄛ")
+    XCTAssertEqual(c.cS2RC("txhj"), "ㄊㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txhd"), "ㄊㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("txa"), "ㄊㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txhf"), "ㄊㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("txad"), "ㄊㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txhj"), "ㄊㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("txaf"), "ㄊㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txa"), "ㄊㄨㄟ")
+    XCTAssertEqual(c.cS2RC("txaj"), "ㄊㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txad"), "ㄊㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("txm"), "ㄊㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txaf"), "ㄊㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("txmd"), "ㄊㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txaj"), "ㄊㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("txmf"), "ㄊㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txm"), "ㄊㄨㄢ")
+    XCTAssertEqual(c.cS2RC("txmj"), "ㄊㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txmd"), "ㄊㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("txn"), "ㄊㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txmf"), "ㄊㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("txnd"), "ㄊㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txmj"), "ㄊㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("txnf"), "ㄊㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txn"), "ㄊㄨㄣ")
+    XCTAssertEqual(c.cS2RC("txnj"), "ㄊㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txnd"), "ㄊㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("txl"), "ㄊㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txnf"), "ㄊㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("txld"), "ㄊㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txnj"), "ㄊㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("txlf"), "ㄊㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txl"), "ㄊㄨㄥ")
+    XCTAssertEqual(c.cS2RC("txlj"), "ㄊㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txld"), "ㄊㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("ny"), "ㄋㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txlf"), "ㄊㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("nyd"), "ㄋㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("txlj"), "ㄊㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("nyf"), "ㄋㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ny"), "ㄋㄚ")
+    XCTAssertEqual(c.cS2RC("nyj"), "ㄋㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nyd"), "ㄋㄚˊ")
+    XCTAssertEqual(c.cS2RC("nys"), "ㄋㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nyf"), "ㄋㄚˇ")
+    XCTAssertEqual(c.cS2RC("ngj"), "ㄋㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nyj"), "ㄋㄚˋ")
+    XCTAssertEqual(c.cS2RC("ngs"), "ㄋㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nys"), "ㄋㄚ˙")
+    XCTAssertEqual(c.cS2RC("nid"), "ㄋㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ngj"), "ㄋㄜˋ")
+    XCTAssertEqual(c.cS2RC("nif"), "ㄋㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ngs"), "ㄋㄜ˙")
+    XCTAssertEqual(c.cS2RC("nij"), "ㄋㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nid"), "ㄋㄞˊ")
+    XCTAssertEqual(c.cS2RC("nad"), "ㄋㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nif"), "ㄋㄞˇ")
+    XCTAssertEqual(c.cS2RC("naf"), "ㄋㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nij"), "ㄋㄞˋ")
+    XCTAssertEqual(c.cS2RC("naj"), "ㄋㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nad"), "ㄋㄟˊ")
+    XCTAssertEqual(c.cS2RC("nw"), "ㄋㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("naf"), "ㄋㄟˇ")
+    XCTAssertEqual(c.cS2RC("nwd"), "ㄋㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("naj"), "ㄋㄟˋ")
+    XCTAssertEqual(c.cS2RC("nwf"), "ㄋㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nw"), "ㄋㄠ")
+    XCTAssertEqual(c.cS2RC("nwj"), "ㄋㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nwd"), "ㄋㄠˊ")
+    XCTAssertEqual(c.cS2RC("nod"), "ㄋㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nwf"), "ㄋㄠˇ")
+    XCTAssertEqual(c.cS2RC("nof"), "ㄋㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nwj"), "ㄋㄠˋ")
+    XCTAssertEqual(c.cS2RC("noj"), "ㄋㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nod"), "ㄋㄡˊ")
+    XCTAssertEqual(c.cS2RC("nm"), "ㄋㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nof"), "ㄋㄡˇ")
+    XCTAssertEqual(c.cS2RC("nmd"), "ㄋㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("noj"), "ㄋㄡˋ")
+    XCTAssertEqual(c.cS2RC("nmf"), "ㄋㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nm"), "ㄋㄢ")
+    XCTAssertEqual(c.cS2RC("nmj"), "ㄋㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nmd"), "ㄋㄢˊ")
+    XCTAssertEqual(c.cS2RC("nnf"), "ㄋㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nmf"), "ㄋㄢˇ")
+    XCTAssertEqual(c.cS2RC("nnj"), "ㄋㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nmj"), "ㄋㄢˋ")
+    XCTAssertEqual(c.cS2RC("nk"), "ㄋㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nnf"), "ㄋㄣˇ")
+    XCTAssertEqual(c.cS2RC("nkd"), "ㄋㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nnj"), "ㄋㄣˋ")
+    XCTAssertEqual(c.cS2RC("nkf"), "ㄋㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nk"), "ㄋㄤ")
+    XCTAssertEqual(c.cS2RC("nkj"), "ㄋㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nkd"), "ㄋㄤˊ")
+    XCTAssertEqual(c.cS2RC("nks"), "ㄋㄤ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nkf"), "ㄋㄤˇ")
+    XCTAssertEqual(c.cS2RC("nld"), "ㄋㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nkj"), "ㄋㄤˋ")
+    XCTAssertEqual(c.cS2RC("nlf"), "ㄋㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nks"), "ㄋㄤ˙")
+    XCTAssertEqual(c.cS2RC("ne"), "ㄋㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nld"), "ㄋㄥˊ")
+    XCTAssertEqual(c.cS2RC("ned"), "ㄋㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nlf"), "ㄋㄥˇ")
+    XCTAssertEqual(c.cS2RC("nef"), "ㄋㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ne"), "ㄋㄧ")
+    XCTAssertEqual(c.cS2RC("nej"), "ㄋㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ned"), "ㄋㄧˊ")
+    XCTAssertEqual(c.cS2RC("nee"), "ㄋㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nef"), "ㄋㄧˇ")
+    XCTAssertEqual(c.cS2RC("need"), "ㄋㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nej"), "ㄋㄧˋ")
+    XCTAssertEqual(c.cS2RC("neej"), "ㄋㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nee"), "ㄋㄧㄝ")
+    XCTAssertEqual(c.cS2RC("newf"), "ㄋㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("need"), "ㄋㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("newj"), "ㄋㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("neej"), "ㄋㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("neo"), "ㄋㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("newf"), "ㄋㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("neod"), "ㄋㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("newj"), "ㄋㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("neof"), "ㄋㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("neo"), "ㄋㄧㄡ")
+    XCTAssertEqual(c.cS2RC("neoj"), "ㄋㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("neod"), "ㄋㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("nem"), "ㄋㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("neof"), "ㄋㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("nemd"), "ㄋㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("neoj"), "ㄋㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("nemf"), "ㄋㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nem"), "ㄋㄧㄢ")
+    XCTAssertEqual(c.cS2RC("nemj"), "ㄋㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nemd"), "ㄋㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("nen"), "ㄋㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nemf"), "ㄋㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("nend"), "ㄋㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nemj"), "ㄋㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("nenf"), "ㄋㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nen"), "ㄋㄧㄣ")
+    XCTAssertEqual(c.cS2RC("nenj"), "ㄋㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nend"), "ㄋㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("nekd"), "ㄋㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nenf"), "ㄋㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("nekf"), "ㄋㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nenj"), "ㄋㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("nekj"), "ㄋㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nekd"), "ㄋㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("neld"), "ㄋㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nekf"), "ㄋㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("nelf"), "ㄋㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nekj"), "ㄋㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("nelj"), "ㄋㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("neld"), "ㄋㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("nxd"), "ㄋㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nelf"), "ㄋㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("nxf"), "ㄋㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nelj"), "ㄋㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("nxj"), "ㄋㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxd"), "ㄋㄨˊ")
+    XCTAssertEqual(c.cS2RC("nxhd"), "ㄋㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxf"), "ㄋㄨˇ")
+    XCTAssertEqual(c.cS2RC("nxhf"), "ㄋㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxj"), "ㄋㄨˋ")
+    XCTAssertEqual(c.cS2RC("nxhj"), "ㄋㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxhd"), "ㄋㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("nxad"), "ㄋㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxhf"), "ㄋㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("nxmd"), "ㄋㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxhj"), "ㄋㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("nxmf"), "ㄋㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxad"), "ㄋㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("nxmj"), "ㄋㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxmd"), "ㄋㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("nxnd"), "ㄋㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxmf"), "ㄋㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("nxld"), "ㄋㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxmj"), "ㄋㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("nxlf"), "ㄋㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxnd"), "ㄋㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("nxlj"), "ㄋㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxld"), "ㄋㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("nud"), "ㄋㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxlf"), "ㄋㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("nuf"), "ㄋㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nxlj"), "ㄋㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("nuj"), "ㄋㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nud"), "ㄋㄩˊ")
+    XCTAssertEqual(c.cS2RC("nuej"), "ㄋㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuf"), "ㄋㄩˇ")
+    XCTAssertEqual(c.cS2RC("ly"), "ㄌㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuj"), "ㄋㄩˋ")
+    XCTAssertEqual(c.cS2RC("lyd"), "ㄌㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuej"), "ㄋㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("lyf"), "ㄌㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ly"), "ㄌㄚ")
+    XCTAssertEqual(c.cS2RC("lyj"), "ㄌㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lyd"), "ㄌㄚˊ")
+    XCTAssertEqual(c.cS2RC("lys"), "ㄌㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lyf"), "ㄌㄚˇ")
+    XCTAssertEqual(c.cS2RC("lh"), "ㄌㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lyj"), "ㄌㄚˋ")
+    XCTAssertEqual(c.cS2RC("lhs"), "ㄌㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lys"), "ㄌㄚ˙")
+    XCTAssertEqual(c.cS2RC("lg"), "ㄌㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lh"), "ㄌㄛ")
+    XCTAssertEqual(c.cS2RC("lgd"), "ㄌㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lhs"), "ㄌㄛ˙")
+    XCTAssertEqual(c.cS2RC("lgj"), "ㄌㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lg"), "ㄌㄜ")
+    XCTAssertEqual(c.cS2RC("lgs"), "ㄌㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lgd"), "ㄌㄜˊ")
+    XCTAssertEqual(c.cS2RC("lid"), "ㄌㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lgj"), "ㄌㄜˋ")
+    XCTAssertEqual(c.cS2RC("lif"), "ㄌㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lgs"), "ㄌㄜ˙")
+    XCTAssertEqual(c.cS2RC("lij"), "ㄌㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lid"), "ㄌㄞˊ")
+    XCTAssertEqual(c.cS2RC("la"), "ㄌㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lif"), "ㄌㄞˇ")
+    XCTAssertEqual(c.cS2RC("lad"), "ㄌㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lij"), "ㄌㄞˋ")
+    XCTAssertEqual(c.cS2RC("laf"), "ㄌㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("la"), "ㄌㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lad"), "ㄌㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("laf"), "ㄌㄟˇ")
   }
 }

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Hsu_B.swift

@@ -12,489 +12,489 @@ import XCTest
 
 extension TekkonTestsKeyboardArrangments {
   func testHsuKeysB() throws {
-    var composer = Tekkon.Composer(arrange: .ofHsu)
+    var c = Tekkon.Composer(arrange: .ofHsu)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("laj"), "ㄌㄟˋ")
+    XCTAssertEqual(c.cS2RC("laj"), "ㄌㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("las"), "ㄌㄟ˙")
+    XCTAssertEqual(c.cS2RC("las"), "ㄌㄟ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lw"), "ㄌㄠ")
+    XCTAssertEqual(c.cS2RC("lw"), "ㄌㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lwd"), "ㄌㄠˊ")
+    XCTAssertEqual(c.cS2RC("lwd"), "ㄌㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lwf"), "ㄌㄠˇ")
+    XCTAssertEqual(c.cS2RC("lwf"), "ㄌㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lwj"), "ㄌㄠˋ")
+    XCTAssertEqual(c.cS2RC("lwj"), "ㄌㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lo"), "ㄌㄡ")
+    XCTAssertEqual(c.cS2RC("lo"), "ㄌㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lod"), "ㄌㄡˊ")
+    XCTAssertEqual(c.cS2RC("lod"), "ㄌㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lof"), "ㄌㄡˇ")
+    XCTAssertEqual(c.cS2RC("lof"), "ㄌㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("loj"), "ㄌㄡˋ")
+    XCTAssertEqual(c.cS2RC("loj"), "ㄌㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("los"), "ㄌㄡ˙")
+    XCTAssertEqual(c.cS2RC("los"), "ㄌㄡ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lmd"), "ㄌㄢˊ")
+    XCTAssertEqual(c.cS2RC("lmd"), "ㄌㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lmf"), "ㄌㄢˇ")
+    XCTAssertEqual(c.cS2RC("lmf"), "ㄌㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lmj"), "ㄌㄢˋ")
+    XCTAssertEqual(c.cS2RC("lmj"), "ㄌㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lk"), "ㄌㄤ")
+    XCTAssertEqual(c.cS2RC("lk"), "ㄌㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lkd"), "ㄌㄤˊ")
+    XCTAssertEqual(c.cS2RC("lkd"), "ㄌㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lkf"), "ㄌㄤˇ")
+    XCTAssertEqual(c.cS2RC("lkf"), "ㄌㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lkj"), "ㄌㄤˋ")
+    XCTAssertEqual(c.cS2RC("lkj"), "ㄌㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ll"), "ㄌㄥ")
+    XCTAssertEqual(c.cS2RC("ll"), "ㄌㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lld"), "ㄌㄥˊ")
+    XCTAssertEqual(c.cS2RC("lld"), "ㄌㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("llf"), "ㄌㄥˇ")
+    XCTAssertEqual(c.cS2RC("llf"), "ㄌㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("llj"), "ㄌㄥˋ")
+    XCTAssertEqual(c.cS2RC("llj"), "ㄌㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("le"), "ㄌㄧ")
+    XCTAssertEqual(c.cS2RC("le"), "ㄌㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("led"), "ㄌㄧˊ")
+    XCTAssertEqual(c.cS2RC("led"), "ㄌㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lef"), "ㄌㄧˇ")
+    XCTAssertEqual(c.cS2RC("lef"), "ㄌㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lej"), "ㄌㄧˋ")
+    XCTAssertEqual(c.cS2RC("lej"), "ㄌㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("les"), "ㄌㄧ˙")
+    XCTAssertEqual(c.cS2RC("les"), "ㄌㄧ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leyf"), "ㄌㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("leyf"), "ㄌㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lee"), "ㄌㄧㄝ")
+    XCTAssertEqual(c.cS2RC("lee"), "ㄌㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leed"), "ㄌㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("leed"), "ㄌㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leef"), "ㄌㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("leef"), "ㄌㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leej"), "ㄌㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("leej"), "ㄌㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lew"), "ㄌㄧㄠ")
+    XCTAssertEqual(c.cS2RC("lew"), "ㄌㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lewd"), "ㄌㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("lewd"), "ㄌㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lewf"), "ㄌㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("lewf"), "ㄌㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lewj"), "ㄌㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("lewj"), "ㄌㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leo"), "ㄌㄧㄡ")
+    XCTAssertEqual(c.cS2RC("leo"), "ㄌㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leod"), "ㄌㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("leod"), "ㄌㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leof"), "ㄌㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("leof"), "ㄌㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leoj"), "ㄌㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("leoj"), "ㄌㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lem"), "ㄌㄧㄢ")
+    XCTAssertEqual(c.cS2RC("lem"), "ㄌㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lemd"), "ㄌㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("lemd"), "ㄌㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lemf"), "ㄌㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("lemf"), "ㄌㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lemj"), "ㄌㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("lemj"), "ㄌㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lend"), "ㄌㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("lend"), "ㄌㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lenf"), "ㄌㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("lenf"), "ㄌㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lenj"), "ㄌㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("lenj"), "ㄌㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lekd"), "ㄌㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("lekd"), "ㄌㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lekf"), "ㄌㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("lekf"), "ㄌㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lekj"), "ㄌㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("lekj"), "ㄌㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lel"), "ㄌㄧㄥ")
+    XCTAssertEqual(c.cS2RC("lel"), "ㄌㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("leld"), "ㄌㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("leld"), "ㄌㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lelf"), "ㄌㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("lelf"), "ㄌㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lelj"), "ㄌㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("lelj"), "ㄌㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lx"), "ㄌㄨ")
+    XCTAssertEqual(c.cS2RC("lx"), "ㄌㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxd"), "ㄌㄨˊ")
+    XCTAssertEqual(c.cS2RC("lxd"), "ㄌㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxf"), "ㄌㄨˇ")
+    XCTAssertEqual(c.cS2RC("lxf"), "ㄌㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxj"), "ㄌㄨˋ")
+    XCTAssertEqual(c.cS2RC("lxj"), "ㄌㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxh"), "ㄌㄨㄛ")
+    XCTAssertEqual(c.cS2RC("lxh"), "ㄌㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxhd"), "ㄌㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("lxhd"), "ㄌㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxhf"), "ㄌㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("lxhf"), "ㄌㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxhj"), "ㄌㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("lxhj"), "ㄌㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxhs"), "ㄌㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("lxhs"), "ㄌㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxmd"), "ㄌㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("lxmd"), "ㄌㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxmf"), "ㄌㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("lxmf"), "ㄌㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxmj"), "ㄌㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("lxmj"), "ㄌㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxn"), "ㄌㄨㄣ")
+    XCTAssertEqual(c.cS2RC("lxn"), "ㄌㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxnd"), "ㄌㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("lxnd"), "ㄌㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxnf"), "ㄌㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("lxnf"), "ㄌㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxnj"), "ㄌㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("lxnj"), "ㄌㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxl"), "ㄌㄨㄥ")
+    XCTAssertEqual(c.cS2RC("lxl"), "ㄌㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxld"), "ㄌㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("lxld"), "ㄌㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxlf"), "ㄌㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("lxlf"), "ㄌㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lxlj"), "ㄌㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("lxlj"), "ㄌㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lu"), "ㄌㄩ")
+    XCTAssertEqual(c.cS2RC("lu"), "ㄌㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lud"), "ㄌㄩˊ")
+    XCTAssertEqual(c.cS2RC("lud"), "ㄌㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luf"), "ㄌㄩˇ")
+    XCTAssertEqual(c.cS2RC("luf"), "ㄌㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luj"), "ㄌㄩˋ")
+    XCTAssertEqual(c.cS2RC("luj"), "ㄌㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lue"), "ㄌㄩㄝ")
+    XCTAssertEqual(c.cS2RC("lue"), "ㄌㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luef"), "ㄌㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("luef"), "ㄌㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luej"), "ㄌㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("luej"), "ㄌㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lumd"), "ㄌㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("lumd"), "ㄌㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lumf"), "ㄌㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("lumf"), "ㄌㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gy"), "ㄍㄚ")
+    XCTAssertEqual(c.cS2RC("gy"), "ㄍㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gyd"), "ㄍㄚˊ")
+    XCTAssertEqual(c.cS2RC("gyd"), "ㄍㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gyf"), "ㄍㄚˇ")
+    XCTAssertEqual(c.cS2RC("gyf"), "ㄍㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gyj"), "ㄍㄚˋ")
+    XCTAssertEqual(c.cS2RC("gyj"), "ㄍㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gys"), "ㄍㄚ˙")
+    XCTAssertEqual(c.cS2RC("gys"), "ㄍㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gg"), "ㄍㄜ")
+    XCTAssertEqual(c.cS2RC("gg"), "ㄍㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ggd"), "ㄍㄜˊ")
+    XCTAssertEqual(c.cS2RC("ggd"), "ㄍㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ggf"), "ㄍㄜˇ")
+    XCTAssertEqual(c.cS2RC("ggf"), "ㄍㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ggj"), "ㄍㄜˋ")
+    XCTAssertEqual(c.cS2RC("ggj"), "ㄍㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ggs"), "ㄍㄜ˙")
+    XCTAssertEqual(c.cS2RC("ggs"), "ㄍㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gi"), "ㄍㄞ")
+    XCTAssertEqual(c.cS2RC("gi"), "ㄍㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gif"), "ㄍㄞˇ")
+    XCTAssertEqual(c.cS2RC("gif"), "ㄍㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gij"), "ㄍㄞˋ")
+    XCTAssertEqual(c.cS2RC("gij"), "ㄍㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gaf"), "ㄍㄟˇ")
+    XCTAssertEqual(c.cS2RC("gaf"), "ㄍㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gw"), "ㄍㄠ")
+    XCTAssertEqual(c.cS2RC("gw"), "ㄍㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gwf"), "ㄍㄠˇ")
+    XCTAssertEqual(c.cS2RC("gwf"), "ㄍㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gwj"), "ㄍㄠˋ")
+    XCTAssertEqual(c.cS2RC("gwj"), "ㄍㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("go"), "ㄍㄡ")
+    XCTAssertEqual(c.cS2RC("go"), "ㄍㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gof"), "ㄍㄡˇ")
+    XCTAssertEqual(c.cS2RC("gof"), "ㄍㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("goj"), "ㄍㄡˋ")
+    XCTAssertEqual(c.cS2RC("goj"), "ㄍㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gm"), "ㄍㄢ")
+    XCTAssertEqual(c.cS2RC("gm"), "ㄍㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gmf"), "ㄍㄢˇ")
+    XCTAssertEqual(c.cS2RC("gmf"), "ㄍㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gmj"), "ㄍㄢˋ")
+    XCTAssertEqual(c.cS2RC("gmj"), "ㄍㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gn"), "ㄍㄣ")
+    XCTAssertEqual(c.cS2RC("gn"), "ㄍㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gnd"), "ㄍㄣˊ")
+    XCTAssertEqual(c.cS2RC("gnd"), "ㄍㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gnf"), "ㄍㄣˇ")
+    XCTAssertEqual(c.cS2RC("gnf"), "ㄍㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gnj"), "ㄍㄣˋ")
+    XCTAssertEqual(c.cS2RC("gnj"), "ㄍㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gk"), "ㄍㄤ")
+    XCTAssertEqual(c.cS2RC("gk"), "ㄍㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gkf"), "ㄍㄤˇ")
+    XCTAssertEqual(c.cS2RC("gkf"), "ㄍㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gkj"), "ㄍㄤˋ")
+    XCTAssertEqual(c.cS2RC("gkj"), "ㄍㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gl"), "ㄍㄥ")
+    XCTAssertEqual(c.cS2RC("gl"), "ㄍㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("glf"), "ㄍㄥˇ")
+    XCTAssertEqual(c.cS2RC("glf"), "ㄍㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("glj"), "ㄍㄥˋ")
+    XCTAssertEqual(c.cS2RC("glj"), "ㄍㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gx"), "ㄍㄨ")
+    XCTAssertEqual(c.cS2RC("gx"), "ㄍㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxd"), "ㄍㄨˊ")
+    XCTAssertEqual(c.cS2RC("gxd"), "ㄍㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxf"), "ㄍㄨˇ")
+    XCTAssertEqual(c.cS2RC("gxf"), "ㄍㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxj"), "ㄍㄨˋ")
+    XCTAssertEqual(c.cS2RC("gxj"), "ㄍㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxy"), "ㄍㄨㄚ")
+    XCTAssertEqual(c.cS2RC("gxy"), "ㄍㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxyd"), "ㄍㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("gxyd"), "ㄍㄨㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxyf"), "ㄍㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("gxyf"), "ㄍㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxyj"), "ㄍㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("gxyj"), "ㄍㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxh"), "ㄍㄨㄛ")
+    XCTAssertEqual(c.cS2RC("gxh"), "ㄍㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxhd"), "ㄍㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("gxhd"), "ㄍㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxhf"), "ㄍㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("gxhf"), "ㄍㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxhj"), "ㄍㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("gxhj"), "ㄍㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxi"), "ㄍㄨㄞ")
+    XCTAssertEqual(c.cS2RC("gxi"), "ㄍㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxif"), "ㄍㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("gxif"), "ㄍㄨㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxij"), "ㄍㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("gxij"), "ㄍㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxa"), "ㄍㄨㄟ")
+    XCTAssertEqual(c.cS2RC("gxa"), "ㄍㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxaf"), "ㄍㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("gxaf"), "ㄍㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxaj"), "ㄍㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("gxaj"), "ㄍㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxm"), "ㄍㄨㄢ")
+    XCTAssertEqual(c.cS2RC("gxm"), "ㄍㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxmf"), "ㄍㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("gxmf"), "ㄍㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxmj"), "ㄍㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("gxmj"), "ㄍㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxn"), "ㄍㄨㄣ")
+    XCTAssertEqual(c.cS2RC("gxn"), "ㄍㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxnf"), "ㄍㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("gxnf"), "ㄍㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxnj"), "ㄍㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("gxnj"), "ㄍㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxk"), "ㄍㄨㄤ")
+    XCTAssertEqual(c.cS2RC("gxk"), "ㄍㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxkf"), "ㄍㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("gxkf"), "ㄍㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxkj"), "ㄍㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("gxkj"), "ㄍㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxl"), "ㄍㄨㄥ")
+    XCTAssertEqual(c.cS2RC("gxl"), "ㄍㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxld"), "ㄍㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("gxld"), "ㄍㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxlf"), "ㄍㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("gxlf"), "ㄍㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gxlj"), "ㄍㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("gxlj"), "ㄍㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ky"), "ㄎㄚ")
+    XCTAssertEqual(c.cS2RC("ky"), "ㄎㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kyf"), "ㄎㄚˇ")
+    XCTAssertEqual(c.cS2RC("kyf"), "ㄎㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kyj"), "ㄎㄚˋ")
+    XCTAssertEqual(c.cS2RC("kyj"), "ㄎㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kg"), "ㄎㄜ")
+    XCTAssertEqual(c.cS2RC("kg"), "ㄎㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kgd"), "ㄎㄜˊ")
+    XCTAssertEqual(c.cS2RC("kgd"), "ㄎㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kgf"), "ㄎㄜˇ")
+    XCTAssertEqual(c.cS2RC("kgf"), "ㄎㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kgj"), "ㄎㄜˋ")
+    XCTAssertEqual(c.cS2RC("kgj"), "ㄎㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ki"), "ㄎㄞ")
+    XCTAssertEqual(c.cS2RC("ki"), "ㄎㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kif"), "ㄎㄞˇ")
+    XCTAssertEqual(c.cS2RC("kif"), "ㄎㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kij"), "ㄎㄞˋ")
+    XCTAssertEqual(c.cS2RC("kij"), "ㄎㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kw"), "ㄎㄠ")
+    XCTAssertEqual(c.cS2RC("kw"), "ㄎㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kwf"), "ㄎㄠˇ")
+    XCTAssertEqual(c.cS2RC("kwf"), "ㄎㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kwj"), "ㄎㄠˋ")
+    XCTAssertEqual(c.cS2RC("kwj"), "ㄎㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ko"), "ㄎㄡ")
+    XCTAssertEqual(c.cS2RC("ko"), "ㄎㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kof"), "ㄎㄡˇ")
+    XCTAssertEqual(c.cS2RC("kof"), "ㄎㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("koj"), "ㄎㄡˋ")
+    XCTAssertEqual(c.cS2RC("koj"), "ㄎㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("km"), "ㄎㄢ")
+    XCTAssertEqual(c.cS2RC("km"), "ㄎㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kmf"), "ㄎㄢˇ")
+    XCTAssertEqual(c.cS2RC("kmf"), "ㄎㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kmj"), "ㄎㄢˋ")
+    XCTAssertEqual(c.cS2RC("kmj"), "ㄎㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kn"), "ㄎㄣ")
+    XCTAssertEqual(c.cS2RC("kn"), "ㄎㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("knf"), "ㄎㄣˇ")
+    XCTAssertEqual(c.cS2RC("knf"), "ㄎㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("knj"), "ㄎㄣˋ")
+    XCTAssertEqual(c.cS2RC("knj"), "ㄎㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kk"), "ㄎㄤ")
+    XCTAssertEqual(c.cS2RC("kk"), "ㄎㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kkd"), "ㄎㄤˊ")
+    XCTAssertEqual(c.cS2RC("kkd"), "ㄎㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kkf"), "ㄎㄤˇ")
+    XCTAssertEqual(c.cS2RC("kkf"), "ㄎㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kkj"), "ㄎㄤˋ")
+    XCTAssertEqual(c.cS2RC("kkj"), "ㄎㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kl"), "ㄎㄥ")
+    XCTAssertEqual(c.cS2RC("kl"), "ㄎㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("klf"), "ㄎㄥˇ")
+    XCTAssertEqual(c.cS2RC("klf"), "ㄎㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kx"), "ㄎㄨ")
+    XCTAssertEqual(c.cS2RC("kx"), "ㄎㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxd"), "ㄎㄨˊ")
+    XCTAssertEqual(c.cS2RC("kxd"), "ㄎㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxf"), "ㄎㄨˇ")
+    XCTAssertEqual(c.cS2RC("kxf"), "ㄎㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxj"), "ㄎㄨˋ")
+    XCTAssertEqual(c.cS2RC("kxj"), "ㄎㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxy"), "ㄎㄨㄚ")
+    XCTAssertEqual(c.cS2RC("kxy"), "ㄎㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxyf"), "ㄎㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("kxyf"), "ㄎㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxyj"), "ㄎㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("kxyj"), "ㄎㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxhj"), "ㄎㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("kxhj"), "ㄎㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxi"), "ㄎㄨㄞ")
+    XCTAssertEqual(c.cS2RC("kxi"), "ㄎㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxif"), "ㄎㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("kxif"), "ㄎㄨㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxij"), "ㄎㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("kxij"), "ㄎㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxa"), "ㄎㄨㄟ")
+    XCTAssertEqual(c.cS2RC("kxa"), "ㄎㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxad"), "ㄎㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("kxad"), "ㄎㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxaf"), "ㄎㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("kxaf"), "ㄎㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxaj"), "ㄎㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("kxaj"), "ㄎㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxm"), "ㄎㄨㄢ")
+    XCTAssertEqual(c.cS2RC("kxm"), "ㄎㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxmf"), "ㄎㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("kxmf"), "ㄎㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxmj"), "ㄎㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("kxmj"), "ㄎㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxn"), "ㄎㄨㄣ")
+    XCTAssertEqual(c.cS2RC("kxn"), "ㄎㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxnf"), "ㄎㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("kxnf"), "ㄎㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxnj"), "ㄎㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("kxnj"), "ㄎㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxk"), "ㄎㄨㄤ")
+    XCTAssertEqual(c.cS2RC("kxk"), "ㄎㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxkd"), "ㄎㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("kxkd"), "ㄎㄨㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxkf"), "ㄎㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("kxkf"), "ㄎㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxkj"), "ㄎㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("kxkj"), "ㄎㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxl"), "ㄎㄨㄥ")
+    XCTAssertEqual(c.cS2RC("kxl"), "ㄎㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxlf"), "ㄎㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("kxlf"), "ㄎㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kxlj"), "ㄎㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("kxlj"), "ㄎㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hy"), "ㄏㄚ")
+    XCTAssertEqual(c.cS2RC("hy"), "ㄏㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hyd"), "ㄏㄚˊ")
+    XCTAssertEqual(c.cS2RC("hyd"), "ㄏㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hyf"), "ㄏㄚˇ")
+    XCTAssertEqual(c.cS2RC("hyf"), "ㄏㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hg"), "ㄏㄜ")
+    XCTAssertEqual(c.cS2RC("hg"), "ㄏㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hgd"), "ㄏㄜˊ")
+    XCTAssertEqual(c.cS2RC("hgd"), "ㄏㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hgf"), "ㄏㄜˇ")
+    XCTAssertEqual(c.cS2RC("hgf"), "ㄏㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hgj"), "ㄏㄜˋ")
+    XCTAssertEqual(c.cS2RC("hgj"), "ㄏㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hi"), "ㄏㄞ")
+    XCTAssertEqual(c.cS2RC("hi"), "ㄏㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hid"), "ㄏㄞˊ")
+    XCTAssertEqual(c.cS2RC("hid"), "ㄏㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hif"), "ㄏㄞˇ")
+    XCTAssertEqual(c.cS2RC("hif"), "ㄏㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hij"), "ㄏㄞˋ")
+    XCTAssertEqual(c.cS2RC("hij"), "ㄏㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ha"), "ㄏㄟ")
+    XCTAssertEqual(c.cS2RC("ha"), "ㄏㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("haf"), "ㄏㄟˇ")
+    XCTAssertEqual(c.cS2RC("haf"), "ㄏㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hw"), "ㄏㄠ")
+    XCTAssertEqual(c.cS2RC("hw"), "ㄏㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hwd"), "ㄏㄠˊ")
+    XCTAssertEqual(c.cS2RC("hwd"), "ㄏㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hwf"), "ㄏㄠˇ")
+    XCTAssertEqual(c.cS2RC("hwf"), "ㄏㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hwj"), "ㄏㄠˋ")
+    XCTAssertEqual(c.cS2RC("hwj"), "ㄏㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ho"), "ㄏㄡ")
+    XCTAssertEqual(c.cS2RC("ho"), "ㄏㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hod"), "ㄏㄡˊ")
+    XCTAssertEqual(c.cS2RC("hod"), "ㄏㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hof"), "ㄏㄡˇ")
+    XCTAssertEqual(c.cS2RC("hof"), "ㄏㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hoj"), "ㄏㄡˋ")
+    XCTAssertEqual(c.cS2RC("hoj"), "ㄏㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hm"), "ㄏㄢ")
+    XCTAssertEqual(c.cS2RC("hm"), "ㄏㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hmd"), "ㄏㄢˊ")
+    XCTAssertEqual(c.cS2RC("hmd"), "ㄏㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hmf"), "ㄏㄢˇ")
+    XCTAssertEqual(c.cS2RC("hmf"), "ㄏㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hmj"), "ㄏㄢˋ")
+    XCTAssertEqual(c.cS2RC("hmj"), "ㄏㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hn"), "ㄏㄣ")
+    XCTAssertEqual(c.cS2RC("hn"), "ㄏㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hnd"), "ㄏㄣˊ")
+    XCTAssertEqual(c.cS2RC("hnd"), "ㄏㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hnf"), "ㄏㄣˇ")
+    XCTAssertEqual(c.cS2RC("hnf"), "ㄏㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hnj"), "ㄏㄣˋ")
+    XCTAssertEqual(c.cS2RC("hnj"), "ㄏㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hk"), "ㄏㄤ")
+    XCTAssertEqual(c.cS2RC("hk"), "ㄏㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hkd"), "ㄏㄤˊ")
+    XCTAssertEqual(c.cS2RC("hkd"), "ㄏㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hkf"), "ㄏㄤˇ")
+    XCTAssertEqual(c.cS2RC("hkf"), "ㄏㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hkj"), "ㄏㄤˋ")
+    XCTAssertEqual(c.cS2RC("hkj"), "ㄏㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hl"), "ㄏㄥ")
+    XCTAssertEqual(c.cS2RC("hl"), "ㄏㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hld"), "ㄏㄥˊ")
+    XCTAssertEqual(c.cS2RC("hld"), "ㄏㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hlj"), "ㄏㄥˋ")
+    XCTAssertEqual(c.cS2RC("hlj"), "ㄏㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hx"), "ㄏㄨ")
+    XCTAssertEqual(c.cS2RC("hx"), "ㄏㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxd"), "ㄏㄨˊ")
+    XCTAssertEqual(c.cS2RC("hxd"), "ㄏㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxf"), "ㄏㄨˇ")
+    XCTAssertEqual(c.cS2RC("hxf"), "ㄏㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxj"), "ㄏㄨˋ")
+    XCTAssertEqual(c.cS2RC("hxj"), "ㄏㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxy"), "ㄏㄨㄚ")
+    XCTAssertEqual(c.cS2RC("hxy"), "ㄏㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxyd"), "ㄏㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("hxyd"), "ㄏㄨㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxyf"), "ㄏㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("hxyf"), "ㄏㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxyj"), "ㄏㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("hxyj"), "ㄏㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxh"), "ㄏㄨㄛ")
+    XCTAssertEqual(c.cS2RC("hxh"), "ㄏㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxhd"), "ㄏㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("hxhd"), "ㄏㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxhf"), "ㄏㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("hxhf"), "ㄏㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxhj"), "ㄏㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("hxhj"), "ㄏㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxhs"), "ㄏㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("hxhs"), "ㄏㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxid"), "ㄏㄨㄞˊ")
+    XCTAssertEqual(c.cS2RC("hxid"), "ㄏㄨㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxij"), "ㄏㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("hxij"), "ㄏㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxa"), "ㄏㄨㄟ")
+    XCTAssertEqual(c.cS2RC("hxa"), "ㄏㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxad"), "ㄏㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("hxad"), "ㄏㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxaf"), "ㄏㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("hxaf"), "ㄏㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxaj"), "ㄏㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("hxaj"), "ㄏㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxm"), "ㄏㄨㄢ")
+    XCTAssertEqual(c.cS2RC("hxm"), "ㄏㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxmd"), "ㄏㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("hxmd"), "ㄏㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxmf"), "ㄏㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("hxmf"), "ㄏㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxmj"), "ㄏㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("hxmj"), "ㄏㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxn"), "ㄏㄨㄣ")
+    XCTAssertEqual(c.cS2RC("hxn"), "ㄏㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxnd"), "ㄏㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("hxnd"), "ㄏㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxnf"), "ㄏㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("hxnf"), "ㄏㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxnj"), "ㄏㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("hxnj"), "ㄏㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxk"), "ㄏㄨㄤ")
+    XCTAssertEqual(c.cS2RC("hxk"), "ㄏㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxkd"), "ㄏㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("hxkd"), "ㄏㄨㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxkf"), "ㄏㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("hxkf"), "ㄏㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxkj"), "ㄏㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("hxkj"), "ㄏㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxks"), "ㄏㄨㄤ˙")
+    XCTAssertEqual(c.cS2RC("hxks"), "ㄏㄨㄤ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxl"), "ㄏㄨㄥ")
+    XCTAssertEqual(c.cS2RC("hxl"), "ㄏㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxld"), "ㄏㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("hxld"), "ㄏㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxlf"), "ㄏㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("hxlf"), "ㄏㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hxlj"), "ㄏㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("hxlj"), "ㄏㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("je"), "ㄐㄧ")
+    XCTAssertEqual(c.cS2RC("je"), "ㄐㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jed"), "ㄐㄧˊ")
+    XCTAssertEqual(c.cS2RC("jed"), "ㄐㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jef"), "ㄐㄧˇ")
+    XCTAssertEqual(c.cS2RC("jef"), "ㄐㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jej"), "ㄐㄧˋ")
+    XCTAssertEqual(c.cS2RC("jej"), "ㄐㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jey"), "ㄐㄧㄚ")
+    XCTAssertEqual(c.cS2RC("jey"), "ㄐㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeyd"), "ㄐㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("jeyd"), "ㄐㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeyf"), "ㄐㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("jeyf"), "ㄐㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeyj"), "ㄐㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("jeyj"), "ㄐㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jee"), "ㄐㄧㄝ")
+    XCTAssertEqual(c.cS2RC("jee"), "ㄐㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeed"), "ㄐㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("jeed"), "ㄐㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeef"), "ㄐㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("jeef"), "ㄐㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeej"), "ㄐㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("jeej"), "ㄐㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jees"), "ㄐㄧㄝ˙")
+    XCTAssertEqual(c.cS2RC("jees"), "ㄐㄧㄝ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jew"), "ㄐㄧㄠ")
+    XCTAssertEqual(c.cS2RC("jew"), "ㄐㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jewd"), "ㄐㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("jewd"), "ㄐㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jewf"), "ㄐㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("jewf"), "ㄐㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jewj"), "ㄐㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("jewj"), "ㄐㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeo"), "ㄐㄧㄡ")
+    XCTAssertEqual(c.cS2RC("jeo"), "ㄐㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeof"), "ㄐㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("jeof"), "ㄐㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jeoj"), "ㄐㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("jeoj"), "ㄐㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jem"), "ㄐㄧㄢ")
+    XCTAssertEqual(c.cS2RC("jem"), "ㄐㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jemf"), "ㄐㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("jemf"), "ㄐㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jemj"), "ㄐㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("jemj"), "ㄐㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jen"), "ㄐㄧㄣ")
+    XCTAssertEqual(c.cS2RC("jen"), "ㄐㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jenf"), "ㄐㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("jenf"), "ㄐㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jenj"), "ㄐㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("jenj"), "ㄐㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jek"), "ㄐㄧㄤ")
+    XCTAssertEqual(c.cS2RC("jek"), "ㄐㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jekd"), "ㄐㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("jekd"), "ㄐㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jekf"), "ㄐㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("jekf"), "ㄐㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jekj"), "ㄐㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("jekj"), "ㄐㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jel"), "ㄐㄧㄥ")
+    XCTAssertEqual(c.cS2RC("jel"), "ㄐㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jelf"), "ㄐㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("jelf"), "ㄐㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jelj"), "ㄐㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("jelj"), "ㄐㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ju"), "ㄐㄩ")
+    XCTAssertEqual(c.cS2RC("ju"), "ㄐㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jud"), "ㄐㄩˊ")
+    XCTAssertEqual(c.cS2RC("jud"), "ㄐㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("juf"), "ㄐㄩˇ")
+    XCTAssertEqual(c.cS2RC("juf"), "ㄐㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("juj"), "ㄐㄩˋ")
+    XCTAssertEqual(c.cS2RC("juj"), "ㄐㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jue"), "ㄐㄩㄝ")
+    XCTAssertEqual(c.cS2RC("jue"), "ㄐㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jued"), "ㄐㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("jued"), "ㄐㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("juef"), "ㄐㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("juef"), "ㄐㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("juej"), "ㄐㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("juej"), "ㄐㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jum"), "ㄐㄩㄢ")
+    XCTAssertEqual(c.cS2RC("jum"), "ㄐㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jumf"), "ㄐㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("jumf"), "ㄐㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jumj"), "ㄐㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("jumj"), "ㄐㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jun"), "ㄐㄩㄣ")
+    XCTAssertEqual(c.cS2RC("jun"), "ㄐㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jund"), "ㄐㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("jund"), "ㄐㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("junf"), "ㄐㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("junf"), "ㄐㄩㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("junj"), "ㄐㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("junj"), "ㄐㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jul"), "ㄐㄩㄥ")
+    XCTAssertEqual(c.cS2RC("jul"), "ㄐㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("julf"), "ㄐㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("julf"), "ㄐㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("julj"), "ㄐㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("julj"), "ㄐㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vs"), "ㄑ˙")
+    XCTAssertEqual(c.cS2RC("vs"), "ㄑ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ve"), "ㄑㄧ")
+    XCTAssertEqual(c.cS2RC("ve"), "ㄑㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ved"), "ㄑㄧˊ")
+    XCTAssertEqual(c.cS2RC("ved"), "ㄑㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vef"), "ㄑㄧˇ")
+    XCTAssertEqual(c.cS2RC("vef"), "ㄑㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vej"), "ㄑㄧˋ")
+    XCTAssertEqual(c.cS2RC("vej"), "ㄑㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vey"), "ㄑㄧㄚ")
+    XCTAssertEqual(c.cS2RC("vey"), "ㄑㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veyd"), "ㄑㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("veyd"), "ㄑㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veyf"), "ㄑㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("veyf"), "ㄑㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veyj"), "ㄑㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("veyj"), "ㄑㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vee"), "ㄑㄧㄝ")
+    XCTAssertEqual(c.cS2RC("vee"), "ㄑㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veed"), "ㄑㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("veed"), "ㄑㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veef"), "ㄑㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("veef"), "ㄑㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veej"), "ㄑㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("veej"), "ㄑㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vew"), "ㄑㄧㄠ")
+    XCTAssertEqual(c.cS2RC("vew"), "ㄑㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vewd"), "ㄑㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("vewd"), "ㄑㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vewf"), "ㄑㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("vewf"), "ㄑㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vewj"), "ㄑㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("vewj"), "ㄑㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veo"), "ㄑㄧㄡ")
+    XCTAssertEqual(c.cS2RC("veo"), "ㄑㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veod"), "ㄑㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("veod"), "ㄑㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veof"), "ㄑㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("veof"), "ㄑㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veoj"), "ㄑㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("veoj"), "ㄑㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vem"), "ㄑㄧㄢ")
+    XCTAssertEqual(c.cS2RC("vem"), "ㄑㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vemd"), "ㄑㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("vemd"), "ㄑㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vemf"), "ㄑㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("vemf"), "ㄑㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vemj"), "ㄑㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("vemj"), "ㄑㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ven"), "ㄑㄧㄣ")
+    XCTAssertEqual(c.cS2RC("ven"), "ㄑㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vend"), "ㄑㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("vend"), "ㄑㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("venf"), "ㄑㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("venf"), "ㄑㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("venj"), "ㄑㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("venj"), "ㄑㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vek"), "ㄑㄧㄤ")
+    XCTAssertEqual(c.cS2RC("vek"), "ㄑㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vekd"), "ㄑㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("vekd"), "ㄑㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vekf"), "ㄑㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("vekf"), "ㄑㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vekj"), "ㄑㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("vekj"), "ㄑㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vel"), "ㄑㄧㄥ")
+    XCTAssertEqual(c.cS2RC("vel"), "ㄑㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("veld"), "ㄑㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("veld"), "ㄑㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("velf"), "ㄑㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("velf"), "ㄑㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("velj"), "ㄑㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("velj"), "ㄑㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vu"), "ㄑㄩ")
+    XCTAssertEqual(c.cS2RC("vu"), "ㄑㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vud"), "ㄑㄩˊ")
+    XCTAssertEqual(c.cS2RC("vud"), "ㄑㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuf"), "ㄑㄩˇ")
+    XCTAssertEqual(c.cS2RC("vuf"), "ㄑㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuj"), "ㄑㄩˋ")
+    XCTAssertEqual(c.cS2RC("vuj"), "ㄑㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vue"), "ㄑㄩㄝ")
+    XCTAssertEqual(c.cS2RC("vue"), "ㄑㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vued"), "ㄑㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("vued"), "ㄑㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuej"), "ㄑㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("vuej"), "ㄑㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vum"), "ㄑㄩㄢ")
+    XCTAssertEqual(c.cS2RC("vum"), "ㄑㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vumd"), "ㄑㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("vumd"), "ㄑㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vumf"), "ㄑㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("vumf"), "ㄑㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vumj"), "ㄑㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("vumj"), "ㄑㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vun"), "ㄑㄩㄣ")
+    XCTAssertEqual(c.cS2RC("vun"), "ㄑㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vund"), "ㄑㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("vund"), "ㄑㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vunf"), "ㄑㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("vunf"), "ㄑㄩㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vunj"), "ㄑㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("vunj"), "ㄑㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vul"), "ㄑㄩㄥ")
+    XCTAssertEqual(c.cS2RC("vul"), "ㄑㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vuld"), "ㄑㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("vuld"), "ㄑㄩㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vulf"), "ㄑㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("vulf"), "ㄑㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("vulj"), "ㄑㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("vulj"), "ㄑㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ce"), "ㄒㄧ")
+    XCTAssertEqual(c.cS2RC("ce"), "ㄒㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ced"), "ㄒㄧˊ")
+    XCTAssertEqual(c.cS2RC("ced"), "ㄒㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cef"), "ㄒㄧˇ")
+    XCTAssertEqual(c.cS2RC("cef"), "ㄒㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cej"), "ㄒㄧˋ")
+    XCTAssertEqual(c.cS2RC("cej"), "ㄒㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cey"), "ㄒㄧㄚ")
+    XCTAssertEqual(c.cS2RC("cey"), "ㄒㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceyd"), "ㄒㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("ceyd"), "ㄒㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceyf"), "ㄒㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("ceyf"), "ㄒㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceyj"), "ㄒㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("ceyj"), "ㄒㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cee"), "ㄒㄧㄝ")
+    XCTAssertEqual(c.cS2RC("cee"), "ㄒㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceed"), "ㄒㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("ceed"), "ㄒㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceef"), "ㄒㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("ceef"), "ㄒㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceej"), "ㄒㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("ceej"), "ㄒㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cew"), "ㄒㄧㄠ")
+    XCTAssertEqual(c.cS2RC("cew"), "ㄒㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cewd"), "ㄒㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("cewd"), "ㄒㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cewf"), "ㄒㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("cewf"), "ㄒㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cewj"), "ㄒㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("cewj"), "ㄒㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceo"), "ㄒㄧㄡ")
+    XCTAssertEqual(c.cS2RC("ceo"), "ㄒㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceod"), "ㄒㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("ceod"), "ㄒㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceof"), "ㄒㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("ceof"), "ㄒㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ceoj"), "ㄒㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("ceoj"), "ㄒㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cem"), "ㄒㄧㄢ")
+    XCTAssertEqual(c.cS2RC("cem"), "ㄒㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cemd"), "ㄒㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("cemd"), "ㄒㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cemf"), "ㄒㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("cemf"), "ㄒㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cemj"), "ㄒㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("cemj"), "ㄒㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cen"), "ㄒㄧㄣ")
+    XCTAssertEqual(c.cS2RC("cen"), "ㄒㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cend"), "ㄒㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("cend"), "ㄒㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cenf"), "ㄒㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("cenf"), "ㄒㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cenj"), "ㄒㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("cenj"), "ㄒㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cek"), "ㄒㄧㄤ")
+    XCTAssertEqual(c.cS2RC("cek"), "ㄒㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cekd"), "ㄒㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("cekd"), "ㄒㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cekf"), "ㄒㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("cekf"), "ㄒㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cekj"), "ㄒㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("cekj"), "ㄒㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cel"), "ㄒㄧㄥ")
+    XCTAssertEqual(c.cS2RC("cel"), "ㄒㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("celd"), "ㄒㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("celd"), "ㄒㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("celf"), "ㄒㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("celf"), "ㄒㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("celj"), "ㄒㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("celj"), "ㄒㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cu"), "ㄒㄩ")
+    XCTAssertEqual(c.cS2RC("cu"), "ㄒㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cud"), "ㄒㄩˊ")
+    XCTAssertEqual(c.cS2RC("cud"), "ㄒㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuf"), "ㄒㄩˇ")
+    XCTAssertEqual(c.cS2RC("cuf"), "ㄒㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuj"), "ㄒㄩˋ")
+    XCTAssertEqual(c.cS2RC("cuj"), "ㄒㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cue"), "ㄒㄩㄝ")
+    XCTAssertEqual(c.cS2RC("cue"), "ㄒㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cued"), "ㄒㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("cued"), "ㄒㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuef"), "ㄒㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("cuef"), "ㄒㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cuej"), "ㄒㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("cuej"), "ㄒㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cum"), "ㄒㄩㄢ")
+    XCTAssertEqual(c.cS2RC("cum"), "ㄒㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cumd"), "ㄒㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("cumd"), "ㄒㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cumf"), "ㄒㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("cumf"), "ㄒㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cumj"), "ㄒㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("cumj"), "ㄒㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cun"), "ㄒㄩㄣ")
+    XCTAssertEqual(c.cS2RC("cun"), "ㄒㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cund"), "ㄒㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("cund"), "ㄒㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cunj"), "ㄒㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("cunj"), "ㄒㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("cul"), "ㄒㄩㄥ")
+    XCTAssertEqual(c.cS2RC("cul"), "ㄒㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("culd"), "ㄒㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("culd"), "ㄒㄩㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("culf"), "ㄒㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("culf"), "ㄒㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("culj"), "ㄒㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("culj"), "ㄒㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("j"), "ㄓ")
+    XCTAssertEqual(c.cS2RC("j"), "ㄓ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jd"), "ㄓˊ")
+    XCTAssertEqual(c.cS2RC("jd"), "ㄓˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jf"), "ㄓˇ")
+    XCTAssertEqual(c.cS2RC("jf"), "ㄓˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jj"), "ㄓˋ")
+    XCTAssertEqual(c.cS2RC("jj"), "ㄓˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jy"), "ㄓㄚ")
+    XCTAssertEqual(c.cS2RC("jy"), "ㄓㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jyd"), "ㄓㄚˊ")
+    XCTAssertEqual(c.cS2RC("jyd"), "ㄓㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jyf"), "ㄓㄚˇ")
+    XCTAssertEqual(c.cS2RC("jyf"), "ㄓㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jyj"), "ㄓㄚˋ")
+    XCTAssertEqual(c.cS2RC("jyj"), "ㄓㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jg"), "ㄓㄜ")
+    XCTAssertEqual(c.cS2RC("jg"), "ㄓㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jgd"), "ㄓㄜˊ")
+    XCTAssertEqual(c.cS2RC("jgd"), "ㄓㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jgf"), "ㄓㄜˇ")
+    XCTAssertEqual(c.cS2RC("jgf"), "ㄓㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jgj"), "ㄓㄜˋ")
+    XCTAssertEqual(c.cS2RC("jgj"), "ㄓㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jgs"), "ㄓㄜ˙")
+    XCTAssertEqual(c.cS2RC("jgs"), "ㄓㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ji"), "ㄓㄞ")
+    XCTAssertEqual(c.cS2RC("ji"), "ㄓㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jid"), "ㄓㄞˊ")
+    XCTAssertEqual(c.cS2RC("jid"), "ㄓㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jif"), "ㄓㄞˇ")
+    XCTAssertEqual(c.cS2RC("jif"), "ㄓㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jij"), "ㄓㄞˋ")
+    XCTAssertEqual(c.cS2RC("jij"), "ㄓㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jaj"), "ㄓㄟˋ")
+    XCTAssertEqual(c.cS2RC("jaj"), "ㄓㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jw"), "ㄓㄠ")
+    XCTAssertEqual(c.cS2RC("jw"), "ㄓㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jwd"), "ㄓㄠˊ")
+    XCTAssertEqual(c.cS2RC("jwd"), "ㄓㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jwf"), "ㄓㄠˇ")
+    XCTAssertEqual(c.cS2RC("jwf"), "ㄓㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jwj"), "ㄓㄠˋ")
+    XCTAssertEqual(c.cS2RC("jwj"), "ㄓㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jo"), "ㄓㄡ")
+    XCTAssertEqual(c.cS2RC("jo"), "ㄓㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jod"), "ㄓㄡˊ")
+    XCTAssertEqual(c.cS2RC("jod"), "ㄓㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jof"), "ㄓㄡˇ")
+    XCTAssertEqual(c.cS2RC("jof"), "ㄓㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("joj"), "ㄓㄡˋ")
+    XCTAssertEqual(c.cS2RC("joj"), "ㄓㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jm"), "ㄓㄢ")
+    XCTAssertEqual(c.cS2RC("jm"), "ㄓㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jmf"), "ㄓㄢˇ")
+    XCTAssertEqual(c.cS2RC("jmf"), "ㄓㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jmj"), "ㄓㄢˋ")
+    XCTAssertEqual(c.cS2RC("jmj"), "ㄓㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jn"), "ㄓㄣ")
+    XCTAssertEqual(c.cS2RC("jn"), "ㄓㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jnd"), "ㄓㄣˊ")
+    XCTAssertEqual(c.cS2RC("jnd"), "ㄓㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jnf"), "ㄓㄣˇ")
+    XCTAssertEqual(c.cS2RC("jnf"), "ㄓㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jnj"), "ㄓㄣˋ")
+    XCTAssertEqual(c.cS2RC("jnj"), "ㄓㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jk"), "ㄓㄤ")
+    XCTAssertEqual(c.cS2RC("jk"), "ㄓㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jkf"), "ㄓㄤˇ")
+    XCTAssertEqual(c.cS2RC("jkf"), "ㄓㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jkj"), "ㄓㄤˋ")
+    XCTAssertEqual(c.cS2RC("jkj"), "ㄓㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jl"), "ㄓㄥ")
+    XCTAssertEqual(c.cS2RC("jl"), "ㄓㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jlf"), "ㄓㄥˇ")
+    XCTAssertEqual(c.cS2RC("jlf"), "ㄓㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jlj"), "ㄓㄥˋ")
+    XCTAssertEqual(c.cS2RC("jlj"), "ㄓㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jx"), "ㄓㄨ")
+    XCTAssertEqual(c.cS2RC("jx"), "ㄓㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jxd"), "ㄓㄨˊ")
+    XCTAssertEqual(c.cS2RC("jxd"), "ㄓㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jxf"), "ㄓㄨˇ")
+    XCTAssertEqual(c.cS2RC("jxf"), "ㄓㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jxj"), "ㄓㄨˋ")
+    XCTAssertEqual(c.cS2RC("jxj"), "ㄓㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jxy"), "ㄓㄨㄚ")
+    XCTAssertEqual(c.cS2RC("jxy"), "ㄓㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jxyf"), "ㄓㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("jxyf"), "ㄓㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jxh"), "ㄓㄨㄛ")
+    XCTAssertEqual(c.cS2RC("jxh"), "ㄓㄨㄛ")
   }
 }

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_A.swift

@@ -11,491 +11,495 @@ import XCTest
 @testable import Tekkon
 
 extension TekkonTestsKeyboardArrangments {
+  func testStarlightKeysTaigi() throws {
+    var c = Tekkon.Composer(arrange: .ofStarlight)
+    XCTAssertEqual(c.cS2RC("kik"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("gif7"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("gin"), "ㄍㄧㄣ")
+  }
+
   func testStarlightKeysA() throws {
-    var composer = Tekkon.Composer(arrange: .ofStarlight)
+    var c = Tekkon.Composer(arrange: .ofStarlight)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kik"), "ㄎㄧㄤ")
+    XCTAssertEqual(c.cS2RC("bik7"), "ㄅㄧㄤˊ")
-    // XCTAssertEqual(composer.convertSequenceToRawComposition("gif7"), "ㄍㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("bik9"), "ㄅㄧㄤˋ")
-    // XCTAssertEqual(composer.convertSequenceToRawComposition("gin"), "ㄍㄧㄣ")
+    XCTAssertEqual(c.cS2RC("duk"), "ㄉㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bik7"), "ㄅㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("ba"), "ㄅㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bik9"), "ㄅㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("ba7"), "ㄅㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duk"), "ㄉㄨㄤ")
+    XCTAssertEqual(c.cS2RC("ba8"), "ㄅㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ba"), "ㄅㄚ")
+    XCTAssertEqual(c.cS2RC("ba9"), "ㄅㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ba7"), "ㄅㄚˊ")
+    XCTAssertEqual(c.cS2RC("ba0"), "ㄅㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ba8"), "ㄅㄚˇ")
+    XCTAssertEqual(c.cS2RC("bo"), "ㄅㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ba9"), "ㄅㄚˋ")
+    XCTAssertEqual(c.cS2RC("bo7"), "ㄅㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ba0"), "ㄅㄚ˙")
+    XCTAssertEqual(c.cS2RC("bo8"), "ㄅㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bo"), "ㄅㄛ")
+    XCTAssertEqual(c.cS2RC("bo9"), "ㄅㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bo7"), "ㄅㄛˊ")
+    XCTAssertEqual(c.cS2RC("bo0"), "ㄅㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bo8"), "ㄅㄛˇ")
+    XCTAssertEqual(c.cS2RC("by"), "ㄅㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bo9"), "ㄅㄛˋ")
+    XCTAssertEqual(c.cS2RC("by7"), "ㄅㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bo0"), "ㄅㄛ˙")
+    XCTAssertEqual(c.cS2RC("by8"), "ㄅㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("by"), "ㄅㄞ")
+    XCTAssertEqual(c.cS2RC("by9"), "ㄅㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("by7"), "ㄅㄞˊ")
+    XCTAssertEqual(c.cS2RC("by0"), "ㄅㄞ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("by8"), "ㄅㄞˇ")
+    XCTAssertEqual(c.cS2RC("bt"), "ㄅㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("by9"), "ㄅㄞˋ")
+    XCTAssertEqual(c.cS2RC("bt8"), "ㄅㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("by0"), "ㄅㄞ˙")
+    XCTAssertEqual(c.cS2RC("bt9"), "ㄅㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bt"), "ㄅㄟ")
+    XCTAssertEqual(c.cS2RC("bt0"), "ㄅㄟ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bt8"), "ㄅㄟˇ")
+    XCTAssertEqual(c.cS2RC("bf"), "ㄅㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bt9"), "ㄅㄟˋ")
+    XCTAssertEqual(c.cS2RC("bf7"), "ㄅㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bt0"), "ㄅㄟ˙")
+    XCTAssertEqual(c.cS2RC("bf8"), "ㄅㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bf"), "ㄅㄠ")
+    XCTAssertEqual(c.cS2RC("bf9"), "ㄅㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bf7"), "ㄅㄠˊ")
+    XCTAssertEqual(c.cS2RC("bm"), "ㄅㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bf8"), "ㄅㄠˇ")
+    XCTAssertEqual(c.cS2RC("bm8"), "ㄅㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bf9"), "ㄅㄠˋ")
+    XCTAssertEqual(c.cS2RC("bm9"), "ㄅㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bm"), "ㄅㄢ")
+    XCTAssertEqual(c.cS2RC("bn"), "ㄅㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bm8"), "ㄅㄢˇ")
+    XCTAssertEqual(c.cS2RC("bn8"), "ㄅㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bm9"), "ㄅㄢˋ")
+    XCTAssertEqual(c.cS2RC("bn9"), "ㄅㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bn"), "ㄅㄣ")
+    XCTAssertEqual(c.cS2RC("bk"), "ㄅㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bn8"), "ㄅㄣˇ")
+    XCTAssertEqual(c.cS2RC("bk8"), "ㄅㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bn9"), "ㄅㄣˋ")
+    XCTAssertEqual(c.cS2RC("bk9"), "ㄅㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bk"), "ㄅㄤ")
+    XCTAssertEqual(c.cS2RC("bg"), "ㄅㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bk8"), "ㄅㄤˇ")
+    XCTAssertEqual(c.cS2RC("bg7"), "ㄅㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bk9"), "ㄅㄤˋ")
+    XCTAssertEqual(c.cS2RC("bg8"), "ㄅㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bg"), "ㄅㄥ")
+    XCTAssertEqual(c.cS2RC("bg9"), "ㄅㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bg7"), "ㄅㄥˊ")
+    XCTAssertEqual(c.cS2RC("bi"), "ㄅㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bg8"), "ㄅㄥˇ")
+    XCTAssertEqual(c.cS2RC("bi7"), "ㄅㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bg9"), "ㄅㄥˋ")
+    XCTAssertEqual(c.cS2RC("bi8"), "ㄅㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bi"), "ㄅㄧ")
+    XCTAssertEqual(c.cS2RC("bi9"), "ㄅㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bi7"), "ㄅㄧˊ")
+    XCTAssertEqual(c.cS2RC("bie"), "ㄅㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bi8"), "ㄅㄧˇ")
+    XCTAssertEqual(c.cS2RC("bie7"), "ㄅㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bi9"), "ㄅㄧˋ")
+    XCTAssertEqual(c.cS2RC("bie8"), "ㄅㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bie"), "ㄅㄧㄝ")
+    XCTAssertEqual(c.cS2RC("bie9"), "ㄅㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bie7"), "ㄅㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("bif"), "ㄅㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bie8"), "ㄅㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("bif8"), "ㄅㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bie9"), "ㄅㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("bif9"), "ㄅㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bif"), "ㄅㄧㄠ")
+    XCTAssertEqual(c.cS2RC("bim"), "ㄅㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bif8"), "ㄅㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("bim7"), "ㄅㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bif9"), "ㄅㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("bim8"), "ㄅㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bim"), "ㄅㄧㄢ")
+    XCTAssertEqual(c.cS2RC("bim9"), "ㄅㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bim7"), "ㄅㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("bin"), "ㄅㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bim8"), "ㄅㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("bin8"), "ㄅㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bim9"), "ㄅㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("bin9"), "ㄅㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bin"), "ㄅㄧㄣ")
+    XCTAssertEqual(c.cS2RC("big"), "ㄅㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bin8"), "ㄅㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("big8"), "ㄅㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bin9"), "ㄅㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("big9"), "ㄅㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("big"), "ㄅㄧㄥ")
+    XCTAssertEqual(c.cS2RC("bu"), "ㄅㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("big8"), "ㄅㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("bu7"), "ㄅㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("big9"), "ㄅㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("bu8"), "ㄅㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bu"), "ㄅㄨ")
+    XCTAssertEqual(c.cS2RC("bu9"), "ㄅㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bu7"), "ㄅㄨˊ")
+    XCTAssertEqual(c.cS2RC("pa"), "ㄆㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bu8"), "ㄅㄨˇ")
+    XCTAssertEqual(c.cS2RC("pa7"), "ㄆㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("bu9"), "ㄅㄨˋ")
+    XCTAssertEqual(c.cS2RC("pa8"), "ㄆㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pa"), "ㄆㄚ")
+    XCTAssertEqual(c.cS2RC("pa9"), "ㄆㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pa7"), "ㄆㄚˊ")
+    XCTAssertEqual(c.cS2RC("pa0"), "ㄆㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pa8"), "ㄆㄚˇ")
+    XCTAssertEqual(c.cS2RC("po"), "ㄆㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pa9"), "ㄆㄚˋ")
+    XCTAssertEqual(c.cS2RC("po7"), "ㄆㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pa0"), "ㄆㄚ˙")
+    XCTAssertEqual(c.cS2RC("po8"), "ㄆㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("po"), "ㄆㄛ")
+    XCTAssertEqual(c.cS2RC("po9"), "ㄆㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("po7"), "ㄆㄛˊ")
+    XCTAssertEqual(c.cS2RC("py"), "ㄆㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("po8"), "ㄆㄛˇ")
+    XCTAssertEqual(c.cS2RC("py7"), "ㄆㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("po9"), "ㄆㄛˋ")
+    XCTAssertEqual(c.cS2RC("py8"), "ㄆㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("py"), "ㄆㄞ")
+    XCTAssertEqual(c.cS2RC("py9"), "ㄆㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("py7"), "ㄆㄞˊ")
+    XCTAssertEqual(c.cS2RC("pt"), "ㄆㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("py8"), "ㄆㄞˇ")
+    XCTAssertEqual(c.cS2RC("pt7"), "ㄆㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("py9"), "ㄆㄞˋ")
+    XCTAssertEqual(c.cS2RC("pt8"), "ㄆㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pt"), "ㄆㄟ")
+    XCTAssertEqual(c.cS2RC("pt9"), "ㄆㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pt7"), "ㄆㄟˊ")
+    XCTAssertEqual(c.cS2RC("pf"), "ㄆㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pt8"), "ㄆㄟˇ")
+    XCTAssertEqual(c.cS2RC("pf7"), "ㄆㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pt9"), "ㄆㄟˋ")
+    XCTAssertEqual(c.cS2RC("pf8"), "ㄆㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pf"), "ㄆㄠ")
+    XCTAssertEqual(c.cS2RC("pf9"), "ㄆㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pf7"), "ㄆㄠˊ")
+    XCTAssertEqual(c.cS2RC("pw"), "ㄆㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pf8"), "ㄆㄠˇ")
+    XCTAssertEqual(c.cS2RC("pw7"), "ㄆㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pf9"), "ㄆㄠˋ")
+    XCTAssertEqual(c.cS2RC("pw8"), "ㄆㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pw"), "ㄆㄡ")
+    XCTAssertEqual(c.cS2RC("pw9"), "ㄆㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pw7"), "ㄆㄡˊ")
+    XCTAssertEqual(c.cS2RC("pm"), "ㄆㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pw8"), "ㄆㄡˇ")
+    XCTAssertEqual(c.cS2RC("pm7"), "ㄆㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pw9"), "ㄆㄡˋ")
+    XCTAssertEqual(c.cS2RC("pm8"), "ㄆㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pm"), "ㄆㄢ")
+    XCTAssertEqual(c.cS2RC("pm9"), "ㄆㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pm7"), "ㄆㄢˊ")
+    XCTAssertEqual(c.cS2RC("pn"), "ㄆㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pm8"), "ㄆㄢˇ")
+    XCTAssertEqual(c.cS2RC("pn7"), "ㄆㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pm9"), "ㄆㄢˋ")
+    XCTAssertEqual(c.cS2RC("pn8"), "ㄆㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pn"), "ㄆㄣ")
+    XCTAssertEqual(c.cS2RC("pn9"), "ㄆㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pn7"), "ㄆㄣˊ")
+    XCTAssertEqual(c.cS2RC("pk"), "ㄆㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pn8"), "ㄆㄣˇ")
+    XCTAssertEqual(c.cS2RC("pk7"), "ㄆㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pn9"), "ㄆㄣˋ")
+    XCTAssertEqual(c.cS2RC("pk8"), "ㄆㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pk"), "ㄆㄤ")
+    XCTAssertEqual(c.cS2RC("pk9"), "ㄆㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pk7"), "ㄆㄤˊ")
+    XCTAssertEqual(c.cS2RC("pg"), "ㄆㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pk8"), "ㄆㄤˇ")
+    XCTAssertEqual(c.cS2RC("pg7"), "ㄆㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pk9"), "ㄆㄤˋ")
+    XCTAssertEqual(c.cS2RC("pg8"), "ㄆㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pg"), "ㄆㄥ")
+    XCTAssertEqual(c.cS2RC("pg9"), "ㄆㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pg7"), "ㄆㄥˊ")
+    XCTAssertEqual(c.cS2RC("pi"), "ㄆㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pg8"), "ㄆㄥˇ")
+    XCTAssertEqual(c.cS2RC("pi7"), "ㄆㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pg9"), "ㄆㄥˋ")
+    XCTAssertEqual(c.cS2RC("pi8"), "ㄆㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pi"), "ㄆㄧ")
+    XCTAssertEqual(c.cS2RC("pi9"), "ㄆㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pi7"), "ㄆㄧˊ")
+    XCTAssertEqual(c.cS2RC("pia"), "ㄆㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pi8"), "ㄆㄧˇ")
+    XCTAssertEqual(c.cS2RC("pie"), "ㄆㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pi9"), "ㄆㄧˋ")
+    XCTAssertEqual(c.cS2RC("pie8"), "ㄆㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pia"), "ㄆㄧㄚ")
+    XCTAssertEqual(c.cS2RC("pie9"), "ㄆㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pie"), "ㄆㄧㄝ")
+    XCTAssertEqual(c.cS2RC("pif"), "ㄆㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pie8"), "ㄆㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("pif7"), "ㄆㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pie9"), "ㄆㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("pif8"), "ㄆㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pif"), "ㄆㄧㄠ")
+    XCTAssertEqual(c.cS2RC("pif9"), "ㄆㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pif7"), "ㄆㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("pim"), "ㄆㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pif8"), "ㄆㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("pim7"), "ㄆㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pif9"), "ㄆㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("pim8"), "ㄆㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pim"), "ㄆㄧㄢ")
+    XCTAssertEqual(c.cS2RC("pim9"), "ㄆㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pim7"), "ㄆㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("pin"), "ㄆㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pim8"), "ㄆㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("pin7"), "ㄆㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pim9"), "ㄆㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("pin8"), "ㄆㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pin"), "ㄆㄧㄣ")
+    XCTAssertEqual(c.cS2RC("pin9"), "ㄆㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pin7"), "ㄆㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("pig"), "ㄆㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pin8"), "ㄆㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("pig7"), "ㄆㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pin9"), "ㄆㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("pig8"), "ㄆㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pig"), "ㄆㄧㄥ")
+    XCTAssertEqual(c.cS2RC("pig9"), "ㄆㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pig7"), "ㄆㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("pu"), "ㄆㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pig8"), "ㄆㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("pu7"), "ㄆㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pig9"), "ㄆㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("pu8"), "ㄆㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pu"), "ㄆㄨ")
+    XCTAssertEqual(c.cS2RC("pu9"), "ㄆㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pu7"), "ㄆㄨˊ")
+    XCTAssertEqual(c.cS2RC("ma"), "ㄇㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pu8"), "ㄆㄨˇ")
+    XCTAssertEqual(c.cS2RC("ma7"), "ㄇㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("pu9"), "ㄆㄨˋ")
+    XCTAssertEqual(c.cS2RC("ma8"), "ㄇㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ma"), "ㄇㄚ")
+    XCTAssertEqual(c.cS2RC("ma9"), "ㄇㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ma7"), "ㄇㄚˊ")
+    XCTAssertEqual(c.cS2RC("ma0"), "ㄇㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ma8"), "ㄇㄚˇ")
+    XCTAssertEqual(c.cS2RC("mo"), "ㄇㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ma9"), "ㄇㄚˋ")
+    XCTAssertEqual(c.cS2RC("mo7"), "ㄇㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ma0"), "ㄇㄚ˙")
+    XCTAssertEqual(c.cS2RC("mo8"), "ㄇㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mo"), "ㄇㄛ")
+    XCTAssertEqual(c.cS2RC("mo9"), "ㄇㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mo7"), "ㄇㄛˊ")
+    XCTAssertEqual(c.cS2RC("mo0"), "ㄇㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mo8"), "ㄇㄛˇ")
+    XCTAssertEqual(c.cS2RC("me"), "ㄇㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mo9"), "ㄇㄛˋ")
+    XCTAssertEqual(c.cS2RC("me9"), "ㄇㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mo0"), "ㄇㄛ˙")
+    XCTAssertEqual(c.cS2RC("me0"), "ㄇㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("me"), "ㄇㄜ")
+    XCTAssertEqual(c.cS2RC("my"), "ㄇㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("me9"), "ㄇㄜˋ")
+    XCTAssertEqual(c.cS2RC("my7"), "ㄇㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("me0"), "ㄇㄜ˙")
+    XCTAssertEqual(c.cS2RC("my8"), "ㄇㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("my"), "ㄇㄞ")
+    XCTAssertEqual(c.cS2RC("my9"), "ㄇㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("my7"), "ㄇㄞˊ")
+    XCTAssertEqual(c.cS2RC("mt7"), "ㄇㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("my8"), "ㄇㄞˇ")
+    XCTAssertEqual(c.cS2RC("mt8"), "ㄇㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("my9"), "ㄇㄞˋ")
+    XCTAssertEqual(c.cS2RC("mt9"), "ㄇㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mt7"), "ㄇㄟˊ")
+    XCTAssertEqual(c.cS2RC("mf"), "ㄇㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mt8"), "ㄇㄟˇ")
+    XCTAssertEqual(c.cS2RC("mf7"), "ㄇㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mt9"), "ㄇㄟˋ")
+    XCTAssertEqual(c.cS2RC("mf8"), "ㄇㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mf"), "ㄇㄠ")
+    XCTAssertEqual(c.cS2RC("mf9"), "ㄇㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mf7"), "ㄇㄠˊ")
+    XCTAssertEqual(c.cS2RC("mw7"), "ㄇㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mf8"), "ㄇㄠˇ")
+    XCTAssertEqual(c.cS2RC("mw8"), "ㄇㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mf9"), "ㄇㄠˋ")
+    XCTAssertEqual(c.cS2RC("mw9"), "ㄇㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mw7"), "ㄇㄡˊ")
+    XCTAssertEqual(c.cS2RC("mm"), "ㄇㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mw8"), "ㄇㄡˇ")
+    XCTAssertEqual(c.cS2RC("mm7"), "ㄇㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mw9"), "ㄇㄡˋ")
+    XCTAssertEqual(c.cS2RC("mm8"), "ㄇㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mm"), "ㄇㄢ")
+    XCTAssertEqual(c.cS2RC("mm9"), "ㄇㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mm7"), "ㄇㄢˊ")
+    XCTAssertEqual(c.cS2RC("mn"), "ㄇㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mm8"), "ㄇㄢˇ")
+    XCTAssertEqual(c.cS2RC("mn7"), "ㄇㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mm9"), "ㄇㄢˋ")
+    XCTAssertEqual(c.cS2RC("mn8"), "ㄇㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mn"), "ㄇㄣ")
+    XCTAssertEqual(c.cS2RC("mn9"), "ㄇㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mn7"), "ㄇㄣˊ")
+    XCTAssertEqual(c.cS2RC("mn0"), "ㄇㄣ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mn8"), "ㄇㄣˇ")
+    XCTAssertEqual(c.cS2RC("mk"), "ㄇㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mn9"), "ㄇㄣˋ")
+    XCTAssertEqual(c.cS2RC("mk7"), "ㄇㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mn0"), "ㄇㄣ˙")
+    XCTAssertEqual(c.cS2RC("mk8"), "ㄇㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mk"), "ㄇㄤ")
+    XCTAssertEqual(c.cS2RC("mk9"), "ㄇㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mk7"), "ㄇㄤˊ")
+    XCTAssertEqual(c.cS2RC("mg"), "ㄇㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mk8"), "ㄇㄤˇ")
+    XCTAssertEqual(c.cS2RC("mg7"), "ㄇㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mk9"), "ㄇㄤˋ")
+    XCTAssertEqual(c.cS2RC("mg8"), "ㄇㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mg"), "ㄇㄥ")
+    XCTAssertEqual(c.cS2RC("mg9"), "ㄇㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mg7"), "ㄇㄥˊ")
+    XCTAssertEqual(c.cS2RC("mi"), "ㄇㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mg8"), "ㄇㄥˇ")
+    XCTAssertEqual(c.cS2RC("mi7"), "ㄇㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mg9"), "ㄇㄥˋ")
+    XCTAssertEqual(c.cS2RC("mi8"), "ㄇㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mi"), "ㄇㄧ")
+    XCTAssertEqual(c.cS2RC("mi9"), "ㄇㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mi7"), "ㄇㄧˊ")
+    XCTAssertEqual(c.cS2RC("mie"), "ㄇㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mi8"), "ㄇㄧˇ")
+    XCTAssertEqual(c.cS2RC("mie7"), "ㄇㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mi9"), "ㄇㄧˋ")
+    XCTAssertEqual(c.cS2RC("mie9"), "ㄇㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mie"), "ㄇㄧㄝ")
+    XCTAssertEqual(c.cS2RC("mif"), "ㄇㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mie7"), "ㄇㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("mif7"), "ㄇㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mie9"), "ㄇㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("mif8"), "ㄇㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mif"), "ㄇㄧㄠ")
+    XCTAssertEqual(c.cS2RC("mif9"), "ㄇㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mif7"), "ㄇㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("miw7"), "ㄇㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mif8"), "ㄇㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("miw8"), "ㄇㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mif9"), "ㄇㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("miw9"), "ㄇㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("miw7"), "ㄇㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("mim"), "ㄇㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("miw8"), "ㄇㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("mim7"), "ㄇㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("miw9"), "ㄇㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("mim8"), "ㄇㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mim"), "ㄇㄧㄢ")
+    XCTAssertEqual(c.cS2RC("mim9"), "ㄇㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mim7"), "ㄇㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("min"), "ㄇㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mim8"), "ㄇㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("min7"), "ㄇㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mim9"), "ㄇㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("min8"), "ㄇㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("min"), "ㄇㄧㄣ")
+    XCTAssertEqual(c.cS2RC("mig7"), "ㄇㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("min7"), "ㄇㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("mig8"), "ㄇㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("min8"), "ㄇㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("mig9"), "ㄇㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mig7"), "ㄇㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("mu7"), "ㄇㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mig8"), "ㄇㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("mu8"), "ㄇㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mig9"), "ㄇㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("mu9"), "ㄇㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mu7"), "ㄇㄨˊ")
+    XCTAssertEqual(c.cS2RC("fa"), "ㄈㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mu8"), "ㄇㄨˇ")
+    XCTAssertEqual(c.cS2RC("fa7"), "ㄈㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("mu9"), "ㄇㄨˋ")
+    XCTAssertEqual(c.cS2RC("fa8"), "ㄈㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fa"), "ㄈㄚ")
+    XCTAssertEqual(c.cS2RC("fa9"), "ㄈㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fa7"), "ㄈㄚˊ")
+    XCTAssertEqual(c.cS2RC("fo7"), "ㄈㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fa8"), "ㄈㄚˇ")
+    XCTAssertEqual(c.cS2RC("ft"), "ㄈㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fa9"), "ㄈㄚˋ")
+    XCTAssertEqual(c.cS2RC("ft7"), "ㄈㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fo7"), "ㄈㄛˊ")
+    XCTAssertEqual(c.cS2RC("ft8"), "ㄈㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ft"), "ㄈㄟ")
+    XCTAssertEqual(c.cS2RC("ft9"), "ㄈㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ft7"), "ㄈㄟˊ")
+    XCTAssertEqual(c.cS2RC("fw"), "ㄈㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ft8"), "ㄈㄟˇ")
+    XCTAssertEqual(c.cS2RC("fw7"), "ㄈㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ft9"), "ㄈㄟˋ")
+    XCTAssertEqual(c.cS2RC("fw8"), "ㄈㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fw"), "ㄈㄡ")
+    XCTAssertEqual(c.cS2RC("fw9"), "ㄈㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fw7"), "ㄈㄡˊ")
+    XCTAssertEqual(c.cS2RC("fm"), "ㄈㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fw8"), "ㄈㄡˇ")
+    XCTAssertEqual(c.cS2RC("fm7"), "ㄈㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fw9"), "ㄈㄡˋ")
+    XCTAssertEqual(c.cS2RC("fm8"), "ㄈㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fm"), "ㄈㄢ")
+    XCTAssertEqual(c.cS2RC("fm9"), "ㄈㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fm7"), "ㄈㄢˊ")
+    XCTAssertEqual(c.cS2RC("fn"), "ㄈㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fm8"), "ㄈㄢˇ")
+    XCTAssertEqual(c.cS2RC("fn7"), "ㄈㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fm9"), "ㄈㄢˋ")
+    XCTAssertEqual(c.cS2RC("fn8"), "ㄈㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fn"), "ㄈㄣ")
+    XCTAssertEqual(c.cS2RC("fn9"), "ㄈㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fn7"), "ㄈㄣˊ")
+    XCTAssertEqual(c.cS2RC("fn0"), "ㄈㄣ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fn8"), "ㄈㄣˇ")
+    XCTAssertEqual(c.cS2RC("fk"), "ㄈㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fn9"), "ㄈㄣˋ")
+    XCTAssertEqual(c.cS2RC("fk7"), "ㄈㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fn0"), "ㄈㄣ˙")
+    XCTAssertEqual(c.cS2RC("fk8"), "ㄈㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fk"), "ㄈㄤ")
+    XCTAssertEqual(c.cS2RC("fk9"), "ㄈㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fk7"), "ㄈㄤˊ")
+    XCTAssertEqual(c.cS2RC("fg"), "ㄈㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fk8"), "ㄈㄤˇ")
+    XCTAssertEqual(c.cS2RC("fg7"), "ㄈㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fk9"), "ㄈㄤˋ")
+    XCTAssertEqual(c.cS2RC("fg8"), "ㄈㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fg"), "ㄈㄥ")
+    XCTAssertEqual(c.cS2RC("fg9"), "ㄈㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fg7"), "ㄈㄥˊ")
+    XCTAssertEqual(c.cS2RC("fif9"), "ㄈㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fg8"), "ㄈㄥˇ")
+    XCTAssertEqual(c.cS2RC("fu"), "ㄈㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fg9"), "ㄈㄥˋ")
+    XCTAssertEqual(c.cS2RC("fu7"), "ㄈㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fif9"), "ㄈㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("fu8"), "ㄈㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fu"), "ㄈㄨ")
+    XCTAssertEqual(c.cS2RC("fu9"), "ㄈㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fu7"), "ㄈㄨˊ")
+    XCTAssertEqual(c.cS2RC("da"), "ㄉㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fu8"), "ㄈㄨˇ")
+    XCTAssertEqual(c.cS2RC("da7"), "ㄉㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("fu9"), "ㄈㄨˋ")
+    XCTAssertEqual(c.cS2RC("da8"), "ㄉㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("da"), "ㄉㄚ")
+    XCTAssertEqual(c.cS2RC("da9"), "ㄉㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("da7"), "ㄉㄚˊ")
+    XCTAssertEqual(c.cS2RC("da0"), "ㄉㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("da8"), "ㄉㄚˇ")
+    XCTAssertEqual(c.cS2RC("de"), "ㄉㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("da9"), "ㄉㄚˋ")
+    XCTAssertEqual(c.cS2RC("de7"), "ㄉㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("da0"), "ㄉㄚ˙")
+    XCTAssertEqual(c.cS2RC("de0"), "ㄉㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("de"), "ㄉㄜ")
+    XCTAssertEqual(c.cS2RC("dy"), "ㄉㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("de7"), "ㄉㄜˊ")
+    XCTAssertEqual(c.cS2RC("dy8"), "ㄉㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("de0"), "ㄉㄜ˙")
+    XCTAssertEqual(c.cS2RC("dy9"), "ㄉㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dy"), "ㄉㄞ")
+    XCTAssertEqual(c.cS2RC("dt8"), "ㄉㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dy8"), "ㄉㄞˇ")
+    XCTAssertEqual(c.cS2RC("df"), "ㄉㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dy9"), "ㄉㄞˋ")
+    XCTAssertEqual(c.cS2RC("df7"), "ㄉㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dt8"), "ㄉㄟˇ")
+    XCTAssertEqual(c.cS2RC("df8"), "ㄉㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("df"), "ㄉㄠ")
+    XCTAssertEqual(c.cS2RC("df9"), "ㄉㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("df7"), "ㄉㄠˊ")
+    XCTAssertEqual(c.cS2RC("dw"), "ㄉㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("df8"), "ㄉㄠˇ")
+    XCTAssertEqual(c.cS2RC("dw7"), "ㄉㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("df9"), "ㄉㄠˋ")
+    XCTAssertEqual(c.cS2RC("dw8"), "ㄉㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dw"), "ㄉㄡ")
+    XCTAssertEqual(c.cS2RC("dw9"), "ㄉㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dw7"), "ㄉㄡˊ")
+    XCTAssertEqual(c.cS2RC("dm"), "ㄉㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dw8"), "ㄉㄡˇ")
+    XCTAssertEqual(c.cS2RC("dm8"), "ㄉㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dw9"), "ㄉㄡˋ")
+    XCTAssertEqual(c.cS2RC("dm9"), "ㄉㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dm"), "ㄉㄢ")
+    XCTAssertEqual(c.cS2RC("dn9"), "ㄉㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dm8"), "ㄉㄢˇ")
+    XCTAssertEqual(c.cS2RC("dk"), "ㄉㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dm9"), "ㄉㄢˋ")
+    XCTAssertEqual(c.cS2RC("dk8"), "ㄉㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dn9"), "ㄉㄣˋ")
+    XCTAssertEqual(c.cS2RC("dk9"), "ㄉㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dk"), "ㄉㄤ")
+    XCTAssertEqual(c.cS2RC("dg"), "ㄉㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dk8"), "ㄉㄤˇ")
+    XCTAssertEqual(c.cS2RC("dg8"), "ㄉㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dk9"), "ㄉㄤˋ")
+    XCTAssertEqual(c.cS2RC("dg9"), "ㄉㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dg"), "ㄉㄥ")
+    XCTAssertEqual(c.cS2RC("di"), "ㄉㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dg8"), "ㄉㄥˇ")
+    XCTAssertEqual(c.cS2RC("di7"), "ㄉㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dg9"), "ㄉㄥˋ")
+    XCTAssertEqual(c.cS2RC("di8"), "ㄉㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("di"), "ㄉㄧ")
+    XCTAssertEqual(c.cS2RC("di9"), "ㄉㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("di7"), "ㄉㄧˊ")
+    XCTAssertEqual(c.cS2RC("dia8"), "ㄉㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("di8"), "ㄉㄧˇ")
+    XCTAssertEqual(c.cS2RC("die"), "ㄉㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("di9"), "ㄉㄧˋ")
+    XCTAssertEqual(c.cS2RC("die7"), "ㄉㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dia8"), "ㄉㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("die8"), "ㄉㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("die"), "ㄉㄧㄝ")
+    XCTAssertEqual(c.cS2RC("die9"), "ㄉㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("die7"), "ㄉㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("dif"), "ㄉㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("die8"), "ㄉㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("dif8"), "ㄉㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("die9"), "ㄉㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("dif9"), "ㄉㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dif"), "ㄉㄧㄠ")
+    XCTAssertEqual(c.cS2RC("diw"), "ㄉㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dif8"), "ㄉㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("dim"), "ㄉㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dif9"), "ㄉㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("dim7"), "ㄉㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("diw"), "ㄉㄧㄡ")
+    XCTAssertEqual(c.cS2RC("dim8"), "ㄉㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dim"), "ㄉㄧㄢ")
+    XCTAssertEqual(c.cS2RC("dim9"), "ㄉㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dim7"), "ㄉㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("dig"), "ㄉㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dim8"), "ㄉㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("dig7"), "ㄉㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dim9"), "ㄉㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("dig8"), "ㄉㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dig"), "ㄉㄧㄥ")
+    XCTAssertEqual(c.cS2RC("dig9"), "ㄉㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dig7"), "ㄉㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("du"), "ㄉㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dig8"), "ㄉㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("du7"), "ㄉㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dig9"), "ㄉㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("du8"), "ㄉㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("du"), "ㄉㄨ")
+    XCTAssertEqual(c.cS2RC("du9"), "ㄉㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("du7"), "ㄉㄨˊ")
+    XCTAssertEqual(c.cS2RC("duo"), "ㄉㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("du8"), "ㄉㄨˇ")
+    XCTAssertEqual(c.cS2RC("duo7"), "ㄉㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("du9"), "ㄉㄨˋ")
+    XCTAssertEqual(c.cS2RC("duo8"), "ㄉㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duo"), "ㄉㄨㄛ")
+    XCTAssertEqual(c.cS2RC("duo9"), "ㄉㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duo7"), "ㄉㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("duo0"), "ㄉㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duo8"), "ㄉㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("dut"), "ㄉㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duo9"), "ㄉㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("dut8"), "ㄉㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("duo0"), "ㄉㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("dut9"), "ㄉㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dut"), "ㄉㄨㄟ")
+    XCTAssertEqual(c.cS2RC("dum"), "ㄉㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dut8"), "ㄉㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("dum8"), "ㄉㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dut9"), "ㄉㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("dum9"), "ㄉㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dum"), "ㄉㄨㄢ")
+    XCTAssertEqual(c.cS2RC("dun"), "ㄉㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dum8"), "ㄉㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("dun8"), "ㄉㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dum9"), "ㄉㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("dun9"), "ㄉㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dun"), "ㄉㄨㄣ")
+    XCTAssertEqual(c.cS2RC("dug"), "ㄉㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dun8"), "ㄉㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("dug8"), "ㄉㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dun9"), "ㄉㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("dug9"), "ㄉㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dug"), "ㄉㄨㄥ")
+    XCTAssertEqual(c.cS2RC("ta"), "ㄊㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dug8"), "ㄉㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("ta8"), "ㄊㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("dug9"), "ㄉㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("ta9"), "ㄊㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ta"), "ㄊㄚ")
+    XCTAssertEqual(c.cS2RC("te9"), "ㄊㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ta8"), "ㄊㄚˇ")
+    XCTAssertEqual(c.cS2RC("ty"), "ㄊㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ta9"), "ㄊㄚˋ")
+    XCTAssertEqual(c.cS2RC("ty7"), "ㄊㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("te9"), "ㄊㄜˋ")
+    XCTAssertEqual(c.cS2RC("ty8"), "ㄊㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ty"), "ㄊㄞ")
+    XCTAssertEqual(c.cS2RC("ty9"), "ㄊㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ty7"), "ㄊㄞˊ")
+    XCTAssertEqual(c.cS2RC("ty0"), "ㄊㄞ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ty8"), "ㄊㄞˇ")
+    XCTAssertEqual(c.cS2RC("tf"), "ㄊㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ty9"), "ㄊㄞˋ")
+    XCTAssertEqual(c.cS2RC("tf7"), "ㄊㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ty0"), "ㄊㄞ˙")
+    XCTAssertEqual(c.cS2RC("tf8"), "ㄊㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tf"), "ㄊㄠ")
+    XCTAssertEqual(c.cS2RC("tf9"), "ㄊㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tf7"), "ㄊㄠˊ")
+    XCTAssertEqual(c.cS2RC("tf0"), "ㄊㄠ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tf8"), "ㄊㄠˇ")
+    XCTAssertEqual(c.cS2RC("tw"), "ㄊㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tf9"), "ㄊㄠˋ")
+    XCTAssertEqual(c.cS2RC("tw7"), "ㄊㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tf0"), "ㄊㄠ˙")
+    XCTAssertEqual(c.cS2RC("tw8"), "ㄊㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tw"), "ㄊㄡ")
+    XCTAssertEqual(c.cS2RC("tw9"), "ㄊㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tw7"), "ㄊㄡˊ")
+    XCTAssertEqual(c.cS2RC("tw0"), "ㄊㄡ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tw8"), "ㄊㄡˇ")
+    XCTAssertEqual(c.cS2RC("tm"), "ㄊㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tw9"), "ㄊㄡˋ")
+    XCTAssertEqual(c.cS2RC("tm7"), "ㄊㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tw0"), "ㄊㄡ˙")
+    XCTAssertEqual(c.cS2RC("tm8"), "ㄊㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tm"), "ㄊㄢ")
+    XCTAssertEqual(c.cS2RC("tm9"), "ㄊㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tm7"), "ㄊㄢˊ")
+    XCTAssertEqual(c.cS2RC("tk"), "ㄊㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tm8"), "ㄊㄢˇ")
+    XCTAssertEqual(c.cS2RC("tk7"), "ㄊㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tm9"), "ㄊㄢˋ")
+    XCTAssertEqual(c.cS2RC("tk8"), "ㄊㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tk"), "ㄊㄤ")
+    XCTAssertEqual(c.cS2RC("tk9"), "ㄊㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tk7"), "ㄊㄤˊ")
+    XCTAssertEqual(c.cS2RC("tg"), "ㄊㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tk8"), "ㄊㄤˇ")
+    XCTAssertEqual(c.cS2RC("tg7"), "ㄊㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tk9"), "ㄊㄤˋ")
+    XCTAssertEqual(c.cS2RC("tg9"), "ㄊㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tg"), "ㄊㄥ")
+    XCTAssertEqual(c.cS2RC("ti"), "ㄊㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tg7"), "ㄊㄥˊ")
+    XCTAssertEqual(c.cS2RC("ti7"), "ㄊㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tg9"), "ㄊㄥˋ")
+    XCTAssertEqual(c.cS2RC("ti8"), "ㄊㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ti"), "ㄊㄧ")
+    XCTAssertEqual(c.cS2RC("ti9"), "ㄊㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ti7"), "ㄊㄧˊ")
+    XCTAssertEqual(c.cS2RC("tie"), "ㄊㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ti8"), "ㄊㄧˇ")
+    XCTAssertEqual(c.cS2RC("tie7"), "ㄊㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ti9"), "ㄊㄧˋ")
+    XCTAssertEqual(c.cS2RC("tie8"), "ㄊㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tie"), "ㄊㄧㄝ")
+    XCTAssertEqual(c.cS2RC("tie9"), "ㄊㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tie7"), "ㄊㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("tif"), "ㄊㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tie8"), "ㄊㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("tif7"), "ㄊㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tie9"), "ㄊㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("tif8"), "ㄊㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tif"), "ㄊㄧㄠ")
+    XCTAssertEqual(c.cS2RC("tif9"), "ㄊㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tif7"), "ㄊㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("tim"), "ㄊㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tif8"), "ㄊㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("tim7"), "ㄊㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tif9"), "ㄊㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("tim8"), "ㄊㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tim"), "ㄊㄧㄢ")
+    XCTAssertEqual(c.cS2RC("tim9"), "ㄊㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tim7"), "ㄊㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("tig"), "ㄊㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tim8"), "ㄊㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("tig7"), "ㄊㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tim9"), "ㄊㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("tig8"), "ㄊㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tig"), "ㄊㄧㄥ")
+    XCTAssertEqual(c.cS2RC("tig9"), "ㄊㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tig7"), "ㄊㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("tu"), "ㄊㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tig8"), "ㄊㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("tu7"), "ㄊㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tig9"), "ㄊㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("tu8"), "ㄊㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tu"), "ㄊㄨ")
+    XCTAssertEqual(c.cS2RC("tu9"), "ㄊㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tu7"), "ㄊㄨˊ")
+    XCTAssertEqual(c.cS2RC("tuo"), "ㄊㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tu8"), "ㄊㄨˇ")
+    XCTAssertEqual(c.cS2RC("tuo7"), "ㄊㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tu9"), "ㄊㄨˋ")
+    XCTAssertEqual(c.cS2RC("tuo8"), "ㄊㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tuo"), "ㄊㄨㄛ")
+    XCTAssertEqual(c.cS2RC("tuo9"), "ㄊㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tuo7"), "ㄊㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("tut"), "ㄊㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tuo8"), "ㄊㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("tut7"), "ㄊㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tuo9"), "ㄊㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("tut8"), "ㄊㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tut"), "ㄊㄨㄟ")
+    XCTAssertEqual(c.cS2RC("tut9"), "ㄊㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tut7"), "ㄊㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("tum"), "ㄊㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tut8"), "ㄊㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("tum7"), "ㄊㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tut9"), "ㄊㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("tum8"), "ㄊㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tum"), "ㄊㄨㄢ")
+    XCTAssertEqual(c.cS2RC("tum9"), "ㄊㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tum7"), "ㄊㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("tun"), "ㄊㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tum8"), "ㄊㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("tun7"), "ㄊㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tum9"), "ㄊㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("tun8"), "ㄊㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tun"), "ㄊㄨㄣ")
+    XCTAssertEqual(c.cS2RC("tun9"), "ㄊㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tun7"), "ㄊㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("tug"), "ㄊㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tun8"), "ㄊㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("tug7"), "ㄊㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tun9"), "ㄊㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("tug8"), "ㄊㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tug"), "ㄊㄨㄥ")
+    XCTAssertEqual(c.cS2RC("tug9"), "ㄊㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tug7"), "ㄊㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("na"), "ㄋㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tug8"), "ㄊㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("na7"), "ㄋㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("tug9"), "ㄊㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("na8"), "ㄋㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("na"), "ㄋㄚ")
+    XCTAssertEqual(c.cS2RC("na9"), "ㄋㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("na7"), "ㄋㄚˊ")
+    XCTAssertEqual(c.cS2RC("na0"), "ㄋㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("na8"), "ㄋㄚˇ")
+    XCTAssertEqual(c.cS2RC("ne9"), "ㄋㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("na9"), "ㄋㄚˋ")
+    XCTAssertEqual(c.cS2RC("ne0"), "ㄋㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("na0"), "ㄋㄚ˙")
+    XCTAssertEqual(c.cS2RC("ny7"), "ㄋㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ne9"), "ㄋㄜˋ")
+    XCTAssertEqual(c.cS2RC("ny8"), "ㄋㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ne0"), "ㄋㄜ˙")
+    XCTAssertEqual(c.cS2RC("ny9"), "ㄋㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ny7"), "ㄋㄞˊ")
+    XCTAssertEqual(c.cS2RC("nt7"), "ㄋㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ny8"), "ㄋㄞˇ")
+    XCTAssertEqual(c.cS2RC("nt8"), "ㄋㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ny9"), "ㄋㄞˋ")
+    XCTAssertEqual(c.cS2RC("nt9"), "ㄋㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nt7"), "ㄋㄟˊ")
+    XCTAssertEqual(c.cS2RC("nf"), "ㄋㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nt8"), "ㄋㄟˇ")
+    XCTAssertEqual(c.cS2RC("nf7"), "ㄋㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nt9"), "ㄋㄟˋ")
+    XCTAssertEqual(c.cS2RC("nf8"), "ㄋㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nf"), "ㄋㄠ")
+    XCTAssertEqual(c.cS2RC("nf9"), "ㄋㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nf7"), "ㄋㄠˊ")
+    XCTAssertEqual(c.cS2RC("nw7"), "ㄋㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nf8"), "ㄋㄠˇ")
+    XCTAssertEqual(c.cS2RC("nw8"), "ㄋㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nf9"), "ㄋㄠˋ")
+    XCTAssertEqual(c.cS2RC("nw9"), "ㄋㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nw7"), "ㄋㄡˊ")
+    XCTAssertEqual(c.cS2RC("nm"), "ㄋㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nw8"), "ㄋㄡˇ")
+    XCTAssertEqual(c.cS2RC("nm7"), "ㄋㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nw9"), "ㄋㄡˋ")
+    XCTAssertEqual(c.cS2RC("nm8"), "ㄋㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nm"), "ㄋㄢ")
+    XCTAssertEqual(c.cS2RC("nm9"), "ㄋㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nm7"), "ㄋㄢˊ")
+    XCTAssertEqual(c.cS2RC("nn8"), "ㄋㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nm8"), "ㄋㄢˇ")
+    XCTAssertEqual(c.cS2RC("nn9"), "ㄋㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nm9"), "ㄋㄢˋ")
+    XCTAssertEqual(c.cS2RC("nk"), "ㄋㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nn8"), "ㄋㄣˇ")
+    XCTAssertEqual(c.cS2RC("nk7"), "ㄋㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nn9"), "ㄋㄣˋ")
+    XCTAssertEqual(c.cS2RC("nk8"), "ㄋㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nk"), "ㄋㄤ")
+    XCTAssertEqual(c.cS2RC("nk9"), "ㄋㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nk7"), "ㄋㄤˊ")
+    XCTAssertEqual(c.cS2RC("nk0"), "ㄋㄤ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nk8"), "ㄋㄤˇ")
+    XCTAssertEqual(c.cS2RC("ng7"), "ㄋㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nk9"), "ㄋㄤˋ")
+    XCTAssertEqual(c.cS2RC("ng8"), "ㄋㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nk0"), "ㄋㄤ˙")
+    XCTAssertEqual(c.cS2RC("ni"), "ㄋㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ng7"), "ㄋㄥˊ")
+    XCTAssertEqual(c.cS2RC("ni7"), "ㄋㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ng8"), "ㄋㄥˇ")
+    XCTAssertEqual(c.cS2RC("ni8"), "ㄋㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ni"), "ㄋㄧ")
+    XCTAssertEqual(c.cS2RC("ni9"), "ㄋㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ni7"), "ㄋㄧˊ")
+    XCTAssertEqual(c.cS2RC("nie"), "ㄋㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ni8"), "ㄋㄧˇ")
+    XCTAssertEqual(c.cS2RC("nie7"), "ㄋㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ni9"), "ㄋㄧˋ")
+    XCTAssertEqual(c.cS2RC("nie9"), "ㄋㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nie"), "ㄋㄧㄝ")
+    XCTAssertEqual(c.cS2RC("nif8"), "ㄋㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nie7"), "ㄋㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("nif9"), "ㄋㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nie9"), "ㄋㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("niw"), "ㄋㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nif8"), "ㄋㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("niw7"), "ㄋㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nif9"), "ㄋㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("niw8"), "ㄋㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("niw"), "ㄋㄧㄡ")
+    XCTAssertEqual(c.cS2RC("niw9"), "ㄋㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("niw7"), "ㄋㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("nim"), "ㄋㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("niw8"), "ㄋㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("nim7"), "ㄋㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("niw9"), "ㄋㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("nim8"), "ㄋㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nim"), "ㄋㄧㄢ")
+    XCTAssertEqual(c.cS2RC("nim9"), "ㄋㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nim7"), "ㄋㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("nin"), "ㄋㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nim8"), "ㄋㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("nin7"), "ㄋㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nim9"), "ㄋㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("nin8"), "ㄋㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nin"), "ㄋㄧㄣ")
+    XCTAssertEqual(c.cS2RC("nin9"), "ㄋㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nin7"), "ㄋㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("nik7"), "ㄋㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nin8"), "ㄋㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("nik8"), "ㄋㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nin9"), "ㄋㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("nik9"), "ㄋㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nik7"), "ㄋㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("nig7"), "ㄋㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nik8"), "ㄋㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("nig8"), "ㄋㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nik9"), "ㄋㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("nig9"), "ㄋㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nig7"), "ㄋㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("nu7"), "ㄋㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nig8"), "ㄋㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("nu8"), "ㄋㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nig9"), "ㄋㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("nu9"), "ㄋㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nu7"), "ㄋㄨˊ")
+    XCTAssertEqual(c.cS2RC("nuo7"), "ㄋㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nu8"), "ㄋㄨˇ")
+    XCTAssertEqual(c.cS2RC("nuo8"), "ㄋㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nu9"), "ㄋㄨˋ")
+    XCTAssertEqual(c.cS2RC("nuo9"), "ㄋㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuo7"), "ㄋㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("nut7"), "ㄋㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuo8"), "ㄋㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("num7"), "ㄋㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nuo9"), "ㄋㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("num8"), "ㄋㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nut7"), "ㄋㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("num9"), "ㄋㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("num7"), "ㄋㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("nun7"), "ㄋㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("num8"), "ㄋㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("nug7"), "ㄋㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("num9"), "ㄋㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("nug8"), "ㄋㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nun7"), "ㄋㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("nug9"), "ㄋㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nug7"), "ㄋㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("nv7"), "ㄋㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nug8"), "ㄋㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("nv8"), "ㄋㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nug9"), "ㄋㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("nv9"), "ㄋㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nv7"), "ㄋㄩˊ")
+    XCTAssertEqual(c.cS2RC("nve9"), "ㄋㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nv8"), "ㄋㄩˇ")
+    XCTAssertEqual(c.cS2RC("la"), "ㄌㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nv9"), "ㄋㄩˋ")
+    XCTAssertEqual(c.cS2RC("la7"), "ㄌㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("nve9"), "ㄋㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("la8"), "ㄌㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("la"), "ㄌㄚ")
+    XCTAssertEqual(c.cS2RC("la9"), "ㄌㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("la7"), "ㄌㄚˊ")
+    XCTAssertEqual(c.cS2RC("la0"), "ㄌㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("la8"), "ㄌㄚˇ")
+    XCTAssertEqual(c.cS2RC("lo"), "ㄌㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("la9"), "ㄌㄚˋ")
+    XCTAssertEqual(c.cS2RC("lo0"), "ㄌㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("la0"), "ㄌㄚ˙")
+    XCTAssertEqual(c.cS2RC("le"), "ㄌㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lo"), "ㄌㄛ")
+    XCTAssertEqual(c.cS2RC("le7"), "ㄌㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lo0"), "ㄌㄛ˙")
+    XCTAssertEqual(c.cS2RC("le9"), "ㄌㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("le"), "ㄌㄜ")
+    XCTAssertEqual(c.cS2RC("le0"), "ㄌㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("le7"), "ㄌㄜˊ")
+    XCTAssertEqual(c.cS2RC("ly7"), "ㄌㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("le9"), "ㄌㄜˋ")
+    XCTAssertEqual(c.cS2RC("ly8"), "ㄌㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("le0"), "ㄌㄜ˙")
+    XCTAssertEqual(c.cS2RC("ly9"), "ㄌㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ly7"), "ㄌㄞˊ")
+    XCTAssertEqual(c.cS2RC("lt"), "ㄌㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ly8"), "ㄌㄞˇ")
+    XCTAssertEqual(c.cS2RC("lt7"), "ㄌㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ly9"), "ㄌㄞˋ")
+    XCTAssertEqual(c.cS2RC("lt8"), "ㄌㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lt"), "ㄌㄟ")
+    XCTAssertEqual(c.cS2RC("lt9"), "ㄌㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lt7"), "ㄌㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lt8"), "ㄌㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lt9"), "ㄌㄟˋ")
   }
 }

Packages/vChewing_Tekkon/Tests/TekkonTests/KeyTest_Starlight_B.swift

@@ -12,490 +12,490 @@ import XCTest
 
 extension TekkonTestsKeyboardArrangments {
   func testStarlightKeysB() throws {
-    var composer = Tekkon.Composer(arrange: .ofStarlight)
+    var c = Tekkon.Composer(arrange: .ofStarlight)
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lt0"), "ㄌㄟ˙")
+    XCTAssertEqual(c.cS2RC("lt0"), "ㄌㄟ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lf"), "ㄌㄠ")
+    XCTAssertEqual(c.cS2RC("lf"), "ㄌㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lf7"), "ㄌㄠˊ")
+    XCTAssertEqual(c.cS2RC("lf7"), "ㄌㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lf8"), "ㄌㄠˇ")
+    XCTAssertEqual(c.cS2RC("lf8"), "ㄌㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lf9"), "ㄌㄠˋ")
+    XCTAssertEqual(c.cS2RC("lf9"), "ㄌㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lw"), "ㄌㄡ")
+    XCTAssertEqual(c.cS2RC("lw"), "ㄌㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lw7"), "ㄌㄡˊ")
+    XCTAssertEqual(c.cS2RC("lw7"), "ㄌㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lw8"), "ㄌㄡˇ")
+    XCTAssertEqual(c.cS2RC("lw8"), "ㄌㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lw9"), "ㄌㄡˋ")
+    XCTAssertEqual(c.cS2RC("lw9"), "ㄌㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lw0"), "ㄌㄡ˙")
+    XCTAssertEqual(c.cS2RC("lw0"), "ㄌㄡ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lm7"), "ㄌㄢˊ")
+    XCTAssertEqual(c.cS2RC("lm7"), "ㄌㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lm8"), "ㄌㄢˇ")
+    XCTAssertEqual(c.cS2RC("lm8"), "ㄌㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lm9"), "ㄌㄢˋ")
+    XCTAssertEqual(c.cS2RC("lm9"), "ㄌㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lk"), "ㄌㄤ")
+    XCTAssertEqual(c.cS2RC("lk"), "ㄌㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lk7"), "ㄌㄤˊ")
+    XCTAssertEqual(c.cS2RC("lk7"), "ㄌㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lk8"), "ㄌㄤˇ")
+    XCTAssertEqual(c.cS2RC("lk8"), "ㄌㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lk9"), "ㄌㄤˋ")
+    XCTAssertEqual(c.cS2RC("lk9"), "ㄌㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lg"), "ㄌㄥ")
+    XCTAssertEqual(c.cS2RC("lg"), "ㄌㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lg7"), "ㄌㄥˊ")
+    XCTAssertEqual(c.cS2RC("lg7"), "ㄌㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lg8"), "ㄌㄥˇ")
+    XCTAssertEqual(c.cS2RC("lg8"), "ㄌㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lg9"), "ㄌㄥˋ")
+    XCTAssertEqual(c.cS2RC("lg9"), "ㄌㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("li"), "ㄌㄧ")
+    XCTAssertEqual(c.cS2RC("li"), "ㄌㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("li7"), "ㄌㄧˊ")
+    XCTAssertEqual(c.cS2RC("li7"), "ㄌㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("li8"), "ㄌㄧˇ")
+    XCTAssertEqual(c.cS2RC("li8"), "ㄌㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("li9"), "ㄌㄧˋ")
+    XCTAssertEqual(c.cS2RC("li9"), "ㄌㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("li0"), "ㄌㄧ˙")
+    XCTAssertEqual(c.cS2RC("li0"), "ㄌㄧ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lia8"), "ㄌㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("lia8"), "ㄌㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lie"), "ㄌㄧㄝ")
+    XCTAssertEqual(c.cS2RC("lie"), "ㄌㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lie7"), "ㄌㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("lie7"), "ㄌㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lie8"), "ㄌㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("lie8"), "ㄌㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lie9"), "ㄌㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("lie9"), "ㄌㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lif"), "ㄌㄧㄠ")
+    XCTAssertEqual(c.cS2RC("lif"), "ㄌㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lif7"), "ㄌㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("lif7"), "ㄌㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lif8"), "ㄌㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("lif8"), "ㄌㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lif9"), "ㄌㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("lif9"), "ㄌㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("liw"), "ㄌㄧㄡ")
+    XCTAssertEqual(c.cS2RC("liw"), "ㄌㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("liw7"), "ㄌㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("liw7"), "ㄌㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("liw8"), "ㄌㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("liw8"), "ㄌㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("liw9"), "ㄌㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("liw9"), "ㄌㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lim"), "ㄌㄧㄢ")
+    XCTAssertEqual(c.cS2RC("lim"), "ㄌㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lim7"), "ㄌㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("lim7"), "ㄌㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lim8"), "ㄌㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("lim8"), "ㄌㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lim9"), "ㄌㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("lim9"), "ㄌㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lin7"), "ㄌㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("lin7"), "ㄌㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lin8"), "ㄌㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("lin8"), "ㄌㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lin9"), "ㄌㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("lin9"), "ㄌㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lik7"), "ㄌㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("lik7"), "ㄌㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lik8"), "ㄌㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("lik8"), "ㄌㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lik9"), "ㄌㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("lik9"), "ㄌㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lig"), "ㄌㄧㄥ")
+    XCTAssertEqual(c.cS2RC("lig"), "ㄌㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lig7"), "ㄌㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("lig7"), "ㄌㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lig8"), "ㄌㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("lig8"), "ㄌㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lig9"), "ㄌㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("lig9"), "ㄌㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lu"), "ㄌㄨ")
+    XCTAssertEqual(c.cS2RC("lu"), "ㄌㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lu7"), "ㄌㄨˊ")
+    XCTAssertEqual(c.cS2RC("lu7"), "ㄌㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lu8"), "ㄌㄨˇ")
+    XCTAssertEqual(c.cS2RC("lu8"), "ㄌㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lu9"), "ㄌㄨˋ")
+    XCTAssertEqual(c.cS2RC("lu9"), "ㄌㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luo"), "ㄌㄨㄛ")
+    XCTAssertEqual(c.cS2RC("luo"), "ㄌㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luo7"), "ㄌㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("luo7"), "ㄌㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luo8"), "ㄌㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("luo8"), "ㄌㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luo9"), "ㄌㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("luo9"), "ㄌㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("luo0"), "ㄌㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("luo0"), "ㄌㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lum7"), "ㄌㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("lum7"), "ㄌㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lum8"), "ㄌㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("lum8"), "ㄌㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lum9"), "ㄌㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("lum9"), "ㄌㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lun"), "ㄌㄨㄣ")
+    XCTAssertEqual(c.cS2RC("lun"), "ㄌㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lun7"), "ㄌㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("lun7"), "ㄌㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lun8"), "ㄌㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("lun8"), "ㄌㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lun9"), "ㄌㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("lun9"), "ㄌㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lug"), "ㄌㄨㄥ")
+    XCTAssertEqual(c.cS2RC("lug"), "ㄌㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lug7"), "ㄌㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("lug7"), "ㄌㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lug8"), "ㄌㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("lug8"), "ㄌㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lug9"), "ㄌㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("lug9"), "ㄌㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lv"), "ㄌㄩ")
+    XCTAssertEqual(c.cS2RC("lv"), "ㄌㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lv7"), "ㄌㄩˊ")
+    XCTAssertEqual(c.cS2RC("lv7"), "ㄌㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lv8"), "ㄌㄩˇ")
+    XCTAssertEqual(c.cS2RC("lv8"), "ㄌㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lv9"), "ㄌㄩˋ")
+    XCTAssertEqual(c.cS2RC("lv9"), "ㄌㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lve"), "ㄌㄩㄝ")
+    XCTAssertEqual(c.cS2RC("lve"), "ㄌㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lve8"), "ㄌㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("lve8"), "ㄌㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lve9"), "ㄌㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("lve9"), "ㄌㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lvm7"), "ㄌㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("lvm7"), "ㄌㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("lvm8"), "ㄌㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("lvm8"), "ㄌㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ga"), "ㄍㄚ")
+    XCTAssertEqual(c.cS2RC("ga"), "ㄍㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ga7"), "ㄍㄚˊ")
+    XCTAssertEqual(c.cS2RC("ga7"), "ㄍㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ga8"), "ㄍㄚˇ")
+    XCTAssertEqual(c.cS2RC("ga8"), "ㄍㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ga9"), "ㄍㄚˋ")
+    XCTAssertEqual(c.cS2RC("ga9"), "ㄍㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ga0"), "ㄍㄚ˙")
+    XCTAssertEqual(c.cS2RC("ga0"), "ㄍㄚ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ge"), "ㄍㄜ")
+    XCTAssertEqual(c.cS2RC("ge"), "ㄍㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ge7"), "ㄍㄜˊ")
+    XCTAssertEqual(c.cS2RC("ge7"), "ㄍㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ge8"), "ㄍㄜˇ")
+    XCTAssertEqual(c.cS2RC("ge8"), "ㄍㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ge9"), "ㄍㄜˋ")
+    XCTAssertEqual(c.cS2RC("ge9"), "ㄍㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ge0"), "ㄍㄜ˙")
+    XCTAssertEqual(c.cS2RC("ge0"), "ㄍㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gy"), "ㄍㄞ")
+    XCTAssertEqual(c.cS2RC("gy"), "ㄍㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gy8"), "ㄍㄞˇ")
+    XCTAssertEqual(c.cS2RC("gy8"), "ㄍㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gy9"), "ㄍㄞˋ")
+    XCTAssertEqual(c.cS2RC("gy9"), "ㄍㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gt8"), "ㄍㄟˇ")
+    XCTAssertEqual(c.cS2RC("gt8"), "ㄍㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gf"), "ㄍㄠ")
+    XCTAssertEqual(c.cS2RC("gf"), "ㄍㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gf8"), "ㄍㄠˇ")
+    XCTAssertEqual(c.cS2RC("gf8"), "ㄍㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gf9"), "ㄍㄠˋ")
+    XCTAssertEqual(c.cS2RC("gf9"), "ㄍㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gw"), "ㄍㄡ")
+    XCTAssertEqual(c.cS2RC("gw"), "ㄍㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gw8"), "ㄍㄡˇ")
+    XCTAssertEqual(c.cS2RC("gw8"), "ㄍㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gw9"), "ㄍㄡˋ")
+    XCTAssertEqual(c.cS2RC("gw9"), "ㄍㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gm"), "ㄍㄢ")
+    XCTAssertEqual(c.cS2RC("gm"), "ㄍㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gm8"), "ㄍㄢˇ")
+    XCTAssertEqual(c.cS2RC("gm8"), "ㄍㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gm9"), "ㄍㄢˋ")
+    XCTAssertEqual(c.cS2RC("gm9"), "ㄍㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gn"), "ㄍㄣ")
+    XCTAssertEqual(c.cS2RC("gn"), "ㄍㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gn7"), "ㄍㄣˊ")
+    XCTAssertEqual(c.cS2RC("gn7"), "ㄍㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gn8"), "ㄍㄣˇ")
+    XCTAssertEqual(c.cS2RC("gn8"), "ㄍㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gn9"), "ㄍㄣˋ")
+    XCTAssertEqual(c.cS2RC("gn9"), "ㄍㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gk"), "ㄍㄤ")
+    XCTAssertEqual(c.cS2RC("gk"), "ㄍㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gk8"), "ㄍㄤˇ")
+    XCTAssertEqual(c.cS2RC("gk8"), "ㄍㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gk9"), "ㄍㄤˋ")
+    XCTAssertEqual(c.cS2RC("gk9"), "ㄍㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gg"), "ㄍㄥ")
+    XCTAssertEqual(c.cS2RC("gg"), "ㄍㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gg8"), "ㄍㄥˇ")
+    XCTAssertEqual(c.cS2RC("gg8"), "ㄍㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gg9"), "ㄍㄥˋ")
+    XCTAssertEqual(c.cS2RC("gg9"), "ㄍㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gu"), "ㄍㄨ")
+    XCTAssertEqual(c.cS2RC("gu"), "ㄍㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gu7"), "ㄍㄨˊ")
+    XCTAssertEqual(c.cS2RC("gu7"), "ㄍㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gu8"), "ㄍㄨˇ")
+    XCTAssertEqual(c.cS2RC("gu8"), "ㄍㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gu9"), "ㄍㄨˋ")
+    XCTAssertEqual(c.cS2RC("gu9"), "ㄍㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gua"), "ㄍㄨㄚ")
+    XCTAssertEqual(c.cS2RC("gua"), "ㄍㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gua7"), "ㄍㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("gua7"), "ㄍㄨㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gua8"), "ㄍㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("gua8"), "ㄍㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gua9"), "ㄍㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("gua9"), "ㄍㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guo"), "ㄍㄨㄛ")
+    XCTAssertEqual(c.cS2RC("guo"), "ㄍㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guo7"), "ㄍㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("guo7"), "ㄍㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guo8"), "ㄍㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("guo8"), "ㄍㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guo9"), "ㄍㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("guo9"), "ㄍㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guy"), "ㄍㄨㄞ")
+    XCTAssertEqual(c.cS2RC("guy"), "ㄍㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guy8"), "ㄍㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("guy8"), "ㄍㄨㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guy9"), "ㄍㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("guy9"), "ㄍㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gut"), "ㄍㄨㄟ")
+    XCTAssertEqual(c.cS2RC("gut"), "ㄍㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gut8"), "ㄍㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("gut8"), "ㄍㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gut9"), "ㄍㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("gut9"), "ㄍㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gum"), "ㄍㄨㄢ")
+    XCTAssertEqual(c.cS2RC("gum"), "ㄍㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gum8"), "ㄍㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("gum8"), "ㄍㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gum9"), "ㄍㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("gum9"), "ㄍㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gun"), "ㄍㄨㄣ")
+    XCTAssertEqual(c.cS2RC("gun"), "ㄍㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gun8"), "ㄍㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("gun8"), "ㄍㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gun9"), "ㄍㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("gun9"), "ㄍㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guk"), "ㄍㄨㄤ")
+    XCTAssertEqual(c.cS2RC("guk"), "ㄍㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guk8"), "ㄍㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("guk8"), "ㄍㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("guk9"), "ㄍㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("guk9"), "ㄍㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gug"), "ㄍㄨㄥ")
+    XCTAssertEqual(c.cS2RC("gug"), "ㄍㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gug7"), "ㄍㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("gug7"), "ㄍㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gug8"), "ㄍㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("gug8"), "ㄍㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("gug9"), "ㄍㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("gug9"), "ㄍㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ka"), "ㄎㄚ")
+    XCTAssertEqual(c.cS2RC("ka"), "ㄎㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ka8"), "ㄎㄚˇ")
+    XCTAssertEqual(c.cS2RC("ka8"), "ㄎㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ka9"), "ㄎㄚˋ")
+    XCTAssertEqual(c.cS2RC("ka9"), "ㄎㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ke"), "ㄎㄜ")
+    XCTAssertEqual(c.cS2RC("ke"), "ㄎㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ke7"), "ㄎㄜˊ")
+    XCTAssertEqual(c.cS2RC("ke7"), "ㄎㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ke8"), "ㄎㄜˇ")
+    XCTAssertEqual(c.cS2RC("ke8"), "ㄎㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ke9"), "ㄎㄜˋ")
+    XCTAssertEqual(c.cS2RC("ke9"), "ㄎㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ky"), "ㄎㄞ")
+    XCTAssertEqual(c.cS2RC("ky"), "ㄎㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ky8"), "ㄎㄞˇ")
+    XCTAssertEqual(c.cS2RC("ky8"), "ㄎㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ky9"), "ㄎㄞˋ")
+    XCTAssertEqual(c.cS2RC("ky9"), "ㄎㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kf"), "ㄎㄠ")
+    XCTAssertEqual(c.cS2RC("kf"), "ㄎㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kf8"), "ㄎㄠˇ")
+    XCTAssertEqual(c.cS2RC("kf8"), "ㄎㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kf9"), "ㄎㄠˋ")
+    XCTAssertEqual(c.cS2RC("kf9"), "ㄎㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kw"), "ㄎㄡ")
+    XCTAssertEqual(c.cS2RC("kw"), "ㄎㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kw8"), "ㄎㄡˇ")
+    XCTAssertEqual(c.cS2RC("kw8"), "ㄎㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kw9"), "ㄎㄡˋ")
+    XCTAssertEqual(c.cS2RC("kw9"), "ㄎㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("km"), "ㄎㄢ")
+    XCTAssertEqual(c.cS2RC("km"), "ㄎㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("km8"), "ㄎㄢˇ")
+    XCTAssertEqual(c.cS2RC("km8"), "ㄎㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("km9"), "ㄎㄢˋ")
+    XCTAssertEqual(c.cS2RC("km9"), "ㄎㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kn"), "ㄎㄣ")
+    XCTAssertEqual(c.cS2RC("kn"), "ㄎㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kn8"), "ㄎㄣˇ")
+    XCTAssertEqual(c.cS2RC("kn8"), "ㄎㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kn9"), "ㄎㄣˋ")
+    XCTAssertEqual(c.cS2RC("kn9"), "ㄎㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kk"), "ㄎㄤ")
+    XCTAssertEqual(c.cS2RC("kk"), "ㄎㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kk7"), "ㄎㄤˊ")
+    XCTAssertEqual(c.cS2RC("kk7"), "ㄎㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kk8"), "ㄎㄤˇ")
+    XCTAssertEqual(c.cS2RC("kk8"), "ㄎㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kk9"), "ㄎㄤˋ")
+    XCTAssertEqual(c.cS2RC("kk9"), "ㄎㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kg"), "ㄎㄥ")
+    XCTAssertEqual(c.cS2RC("kg"), "ㄎㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kg8"), "ㄎㄥˇ")
+    XCTAssertEqual(c.cS2RC("kg8"), "ㄎㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ku"), "ㄎㄨ")
+    XCTAssertEqual(c.cS2RC("ku"), "ㄎㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ku7"), "ㄎㄨˊ")
+    XCTAssertEqual(c.cS2RC("ku7"), "ㄎㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ku8"), "ㄎㄨˇ")
+    XCTAssertEqual(c.cS2RC("ku8"), "ㄎㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ku9"), "ㄎㄨˋ")
+    XCTAssertEqual(c.cS2RC("ku9"), "ㄎㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kua"), "ㄎㄨㄚ")
+    XCTAssertEqual(c.cS2RC("kua"), "ㄎㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kua8"), "ㄎㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("kua8"), "ㄎㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kua9"), "ㄎㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("kua9"), "ㄎㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kuo9"), "ㄎㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("kuo9"), "ㄎㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kuy"), "ㄎㄨㄞ")
+    XCTAssertEqual(c.cS2RC("kuy"), "ㄎㄨㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kuy8"), "ㄎㄨㄞˇ")
+    XCTAssertEqual(c.cS2RC("kuy8"), "ㄎㄨㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kuy9"), "ㄎㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("kuy9"), "ㄎㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kut"), "ㄎㄨㄟ")
+    XCTAssertEqual(c.cS2RC("kut"), "ㄎㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kut7"), "ㄎㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("kut7"), "ㄎㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kut8"), "ㄎㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("kut8"), "ㄎㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kut9"), "ㄎㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("kut9"), "ㄎㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kum"), "ㄎㄨㄢ")
+    XCTAssertEqual(c.cS2RC("kum"), "ㄎㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kum8"), "ㄎㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("kum8"), "ㄎㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kum9"), "ㄎㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("kum9"), "ㄎㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kun"), "ㄎㄨㄣ")
+    XCTAssertEqual(c.cS2RC("kun"), "ㄎㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kun8"), "ㄎㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("kun8"), "ㄎㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kun9"), "ㄎㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("kun9"), "ㄎㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kuk"), "ㄎㄨㄤ")
+    XCTAssertEqual(c.cS2RC("kuk"), "ㄎㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kuk7"), "ㄎㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("kuk7"), "ㄎㄨㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kuk8"), "ㄎㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("kuk8"), "ㄎㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kuk9"), "ㄎㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("kuk9"), "ㄎㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kug"), "ㄎㄨㄥ")
+    XCTAssertEqual(c.cS2RC("kug"), "ㄎㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kug8"), "ㄎㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("kug8"), "ㄎㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("kug9"), "ㄎㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("kug9"), "ㄎㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ha"), "ㄏㄚ")
+    XCTAssertEqual(c.cS2RC("ha"), "ㄏㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ha7"), "ㄏㄚˊ")
+    XCTAssertEqual(c.cS2RC("ha7"), "ㄏㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ha8"), "ㄏㄚˇ")
+    XCTAssertEqual(c.cS2RC("ha8"), "ㄏㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("he"), "ㄏㄜ")
+    XCTAssertEqual(c.cS2RC("he"), "ㄏㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("he7"), "ㄏㄜˊ")
+    XCTAssertEqual(c.cS2RC("he7"), "ㄏㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("he8"), "ㄏㄜˇ")
+    XCTAssertEqual(c.cS2RC("he8"), "ㄏㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("he9"), "ㄏㄜˋ")
+    XCTAssertEqual(c.cS2RC("he9"), "ㄏㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hy"), "ㄏㄞ")
+    XCTAssertEqual(c.cS2RC("hy"), "ㄏㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hy7"), "ㄏㄞˊ")
+    XCTAssertEqual(c.cS2RC("hy7"), "ㄏㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hy8"), "ㄏㄞˇ")
+    XCTAssertEqual(c.cS2RC("hy8"), "ㄏㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hy9"), "ㄏㄞˋ")
+    XCTAssertEqual(c.cS2RC("hy9"), "ㄏㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ht"), "ㄏㄟ")
+    XCTAssertEqual(c.cS2RC("ht"), "ㄏㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ht8"), "ㄏㄟˇ")
+    XCTAssertEqual(c.cS2RC("ht8"), "ㄏㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hf"), "ㄏㄠ")
+    XCTAssertEqual(c.cS2RC("hf"), "ㄏㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hf7"), "ㄏㄠˊ")
+    XCTAssertEqual(c.cS2RC("hf7"), "ㄏㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hf8"), "ㄏㄠˇ")
+    XCTAssertEqual(c.cS2RC("hf8"), "ㄏㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hf9"), "ㄏㄠˋ")
+    XCTAssertEqual(c.cS2RC("hf9"), "ㄏㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hw"), "ㄏㄡ")
+    XCTAssertEqual(c.cS2RC("hw"), "ㄏㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hw7"), "ㄏㄡˊ")
+    XCTAssertEqual(c.cS2RC("hw7"), "ㄏㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hw8"), "ㄏㄡˇ")
+    XCTAssertEqual(c.cS2RC("hw8"), "ㄏㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hw9"), "ㄏㄡˋ")
+    XCTAssertEqual(c.cS2RC("hw9"), "ㄏㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hm"), "ㄏㄢ")
+    XCTAssertEqual(c.cS2RC("hm"), "ㄏㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hm7"), "ㄏㄢˊ")
+    XCTAssertEqual(c.cS2RC("hm7"), "ㄏㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hm8"), "ㄏㄢˇ")
+    XCTAssertEqual(c.cS2RC("hm8"), "ㄏㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hm9"), "ㄏㄢˋ")
+    XCTAssertEqual(c.cS2RC("hm9"), "ㄏㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hn"), "ㄏㄣ")
+    XCTAssertEqual(c.cS2RC("hn"), "ㄏㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hn7"), "ㄏㄣˊ")
+    XCTAssertEqual(c.cS2RC("hn7"), "ㄏㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hn8"), "ㄏㄣˇ")
+    XCTAssertEqual(c.cS2RC("hn8"), "ㄏㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hn9"), "ㄏㄣˋ")
+    XCTAssertEqual(c.cS2RC("hn9"), "ㄏㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hk"), "ㄏㄤ")
+    XCTAssertEqual(c.cS2RC("hk"), "ㄏㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hk7"), "ㄏㄤˊ")
+    XCTAssertEqual(c.cS2RC("hk7"), "ㄏㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hk8"), "ㄏㄤˇ")
+    XCTAssertEqual(c.cS2RC("hk8"), "ㄏㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hk9"), "ㄏㄤˋ")
+    XCTAssertEqual(c.cS2RC("hk9"), "ㄏㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hg"), "ㄏㄥ")
+    XCTAssertEqual(c.cS2RC("hg"), "ㄏㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hg7"), "ㄏㄥˊ")
+    XCTAssertEqual(c.cS2RC("hg7"), "ㄏㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hg9"), "ㄏㄥˋ")
+    XCTAssertEqual(c.cS2RC("hg9"), "ㄏㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hu"), "ㄏㄨ")
+    XCTAssertEqual(c.cS2RC("hu"), "ㄏㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hu7"), "ㄏㄨˊ")
+    XCTAssertEqual(c.cS2RC("hu7"), "ㄏㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hu8"), "ㄏㄨˇ")
+    XCTAssertEqual(c.cS2RC("hu8"), "ㄏㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hu9"), "ㄏㄨˋ")
+    XCTAssertEqual(c.cS2RC("hu9"), "ㄏㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hua"), "ㄏㄨㄚ")
+    XCTAssertEqual(c.cS2RC("hua"), "ㄏㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hua7"), "ㄏㄨㄚˊ")
+    XCTAssertEqual(c.cS2RC("hua7"), "ㄏㄨㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hua8"), "ㄏㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("hua8"), "ㄏㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hua9"), "ㄏㄨㄚˋ")
+    XCTAssertEqual(c.cS2RC("hua9"), "ㄏㄨㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huo"), "ㄏㄨㄛ")
+    XCTAssertEqual(c.cS2RC("huo"), "ㄏㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huo7"), "ㄏㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("huo7"), "ㄏㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huo8"), "ㄏㄨㄛˇ")
+    XCTAssertEqual(c.cS2RC("huo8"), "ㄏㄨㄛˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huo9"), "ㄏㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("huo9"), "ㄏㄨㄛˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huo0"), "ㄏㄨㄛ˙")
+    XCTAssertEqual(c.cS2RC("huo0"), "ㄏㄨㄛ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huy7"), "ㄏㄨㄞˊ")
+    XCTAssertEqual(c.cS2RC("huy7"), "ㄏㄨㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huy9"), "ㄏㄨㄞˋ")
+    XCTAssertEqual(c.cS2RC("huy9"), "ㄏㄨㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hut"), "ㄏㄨㄟ")
+    XCTAssertEqual(c.cS2RC("hut"), "ㄏㄨㄟ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hut7"), "ㄏㄨㄟˊ")
+    XCTAssertEqual(c.cS2RC("hut7"), "ㄏㄨㄟˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hut8"), "ㄏㄨㄟˇ")
+    XCTAssertEqual(c.cS2RC("hut8"), "ㄏㄨㄟˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hut9"), "ㄏㄨㄟˋ")
+    XCTAssertEqual(c.cS2RC("hut9"), "ㄏㄨㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hum"), "ㄏㄨㄢ")
+    XCTAssertEqual(c.cS2RC("hum"), "ㄏㄨㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hum7"), "ㄏㄨㄢˊ")
+    XCTAssertEqual(c.cS2RC("hum7"), "ㄏㄨㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hum8"), "ㄏㄨㄢˇ")
+    XCTAssertEqual(c.cS2RC("hum8"), "ㄏㄨㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hum9"), "ㄏㄨㄢˋ")
+    XCTAssertEqual(c.cS2RC("hum9"), "ㄏㄨㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hun"), "ㄏㄨㄣ")
+    XCTAssertEqual(c.cS2RC("hun"), "ㄏㄨㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hun7"), "ㄏㄨㄣˊ")
+    XCTAssertEqual(c.cS2RC("hun7"), "ㄏㄨㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hun8"), "ㄏㄨㄣˇ")
+    XCTAssertEqual(c.cS2RC("hun8"), "ㄏㄨㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hun9"), "ㄏㄨㄣˋ")
+    XCTAssertEqual(c.cS2RC("hun9"), "ㄏㄨㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huk"), "ㄏㄨㄤ")
+    XCTAssertEqual(c.cS2RC("huk"), "ㄏㄨㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huk7"), "ㄏㄨㄤˊ")
+    XCTAssertEqual(c.cS2RC("huk7"), "ㄏㄨㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huk8"), "ㄏㄨㄤˇ")
+    XCTAssertEqual(c.cS2RC("huk8"), "ㄏㄨㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huk9"), "ㄏㄨㄤˋ")
+    XCTAssertEqual(c.cS2RC("huk9"), "ㄏㄨㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("huk0"), "ㄏㄨㄤ˙")
+    XCTAssertEqual(c.cS2RC("huk0"), "ㄏㄨㄤ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hug"), "ㄏㄨㄥ")
+    XCTAssertEqual(c.cS2RC("hug"), "ㄏㄨㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hug7"), "ㄏㄨㄥˊ")
+    XCTAssertEqual(c.cS2RC("hug7"), "ㄏㄨㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hug8"), "ㄏㄨㄥˇ")
+    XCTAssertEqual(c.cS2RC("hug8"), "ㄏㄨㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("hug9"), "ㄏㄨㄥˋ")
+    XCTAssertEqual(c.cS2RC("hug9"), "ㄏㄨㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ji"), "ㄐㄧ")
+    XCTAssertEqual(c.cS2RC("ji"), "ㄐㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ji7"), "ㄐㄧˊ")
+    XCTAssertEqual(c.cS2RC("ji7"), "ㄐㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ji8"), "ㄐㄧˇ")
+    XCTAssertEqual(c.cS2RC("ji8"), "ㄐㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ji9"), "ㄐㄧˋ")
+    XCTAssertEqual(c.cS2RC("ji9"), "ㄐㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jia"), "ㄐㄧㄚ")
+    XCTAssertEqual(c.cS2RC("jia"), "ㄐㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jia7"), "ㄐㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("jia7"), "ㄐㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jia8"), "ㄐㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("jia8"), "ㄐㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jia9"), "ㄐㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("jia9"), "ㄐㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jie"), "ㄐㄧㄝ")
+    XCTAssertEqual(c.cS2RC("jie"), "ㄐㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jie7"), "ㄐㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("jie7"), "ㄐㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jie8"), "ㄐㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("jie8"), "ㄐㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jie9"), "ㄐㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("jie9"), "ㄐㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jie0"), "ㄐㄧㄝ˙")
+    XCTAssertEqual(c.cS2RC("jie0"), "ㄐㄧㄝ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jif"), "ㄐㄧㄠ")
+    XCTAssertEqual(c.cS2RC("jif"), "ㄐㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jif7"), "ㄐㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("jif7"), "ㄐㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jif8"), "ㄐㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("jif8"), "ㄐㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jif9"), "ㄐㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("jif9"), "ㄐㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jiw"), "ㄐㄧㄡ")
+    XCTAssertEqual(c.cS2RC("jiw"), "ㄐㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jiw8"), "ㄐㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("jiw8"), "ㄐㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jiw9"), "ㄐㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("jiw9"), "ㄐㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jim"), "ㄐㄧㄢ")
+    XCTAssertEqual(c.cS2RC("jim"), "ㄐㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jim8"), "ㄐㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("jim8"), "ㄐㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jim9"), "ㄐㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("jim9"), "ㄐㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jin"), "ㄐㄧㄣ")
+    XCTAssertEqual(c.cS2RC("jin"), "ㄐㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jin8"), "ㄐㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("jin8"), "ㄐㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jin9"), "ㄐㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("jin9"), "ㄐㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jik"), "ㄐㄧㄤ")
+    XCTAssertEqual(c.cS2RC("jik"), "ㄐㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jik7"), "ㄐㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("jik7"), "ㄐㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jik8"), "ㄐㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("jik8"), "ㄐㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jik9"), "ㄐㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("jik9"), "ㄐㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jig"), "ㄐㄧㄥ")
+    XCTAssertEqual(c.cS2RC("jig"), "ㄐㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jig8"), "ㄐㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("jig8"), "ㄐㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jig9"), "ㄐㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("jig9"), "ㄐㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jv"), "ㄐㄩ")
+    XCTAssertEqual(c.cS2RC("jv"), "ㄐㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jv7"), "ㄐㄩˊ")
+    XCTAssertEqual(c.cS2RC("jv7"), "ㄐㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jv8"), "ㄐㄩˇ")
+    XCTAssertEqual(c.cS2RC("jv8"), "ㄐㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jv9"), "ㄐㄩˋ")
+    XCTAssertEqual(c.cS2RC("jv9"), "ㄐㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jve"), "ㄐㄩㄝ")
+    XCTAssertEqual(c.cS2RC("jve"), "ㄐㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jve7"), "ㄐㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("jve7"), "ㄐㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jve8"), "ㄐㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("jve8"), "ㄐㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jve9"), "ㄐㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("jve9"), "ㄐㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvm"), "ㄐㄩㄢ")
+    XCTAssertEqual(c.cS2RC("jvm"), "ㄐㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvm8"), "ㄐㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("jvm8"), "ㄐㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvm9"), "ㄐㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("jvm9"), "ㄐㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvn"), "ㄐㄩㄣ")
+    XCTAssertEqual(c.cS2RC("jvn"), "ㄐㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvn7"), "ㄐㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("jvn7"), "ㄐㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvn8"), "ㄐㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("jvn8"), "ㄐㄩㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvn9"), "ㄐㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("jvn9"), "ㄐㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvg"), "ㄐㄩㄥ")
+    XCTAssertEqual(c.cS2RC("jvg"), "ㄐㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvg8"), "ㄐㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("jvg8"), "ㄐㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jvg9"), "ㄐㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("jvg9"), "ㄐㄩㄥˋ")
-    // XCTAssertEqual(composer.convertSequenceToRawComposition("q0"), "ㄑ˙")
+    // XCTAssertEqual(c.cS2RC("q0"), "ㄑ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qi"), "ㄑㄧ")
+    XCTAssertEqual(c.cS2RC("qi"), "ㄑㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qi7"), "ㄑㄧˊ")
+    XCTAssertEqual(c.cS2RC("qi7"), "ㄑㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qi8"), "ㄑㄧˇ")
+    XCTAssertEqual(c.cS2RC("qi8"), "ㄑㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qi9"), "ㄑㄧˋ")
+    XCTAssertEqual(c.cS2RC("qi9"), "ㄑㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qia"), "ㄑㄧㄚ")
+    XCTAssertEqual(c.cS2RC("qia"), "ㄑㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qia7"), "ㄑㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("qia7"), "ㄑㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qia8"), "ㄑㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("qia8"), "ㄑㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qia9"), "ㄑㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("qia9"), "ㄑㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qie"), "ㄑㄧㄝ")
+    XCTAssertEqual(c.cS2RC("qie"), "ㄑㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qie7"), "ㄑㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("qie7"), "ㄑㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qie8"), "ㄑㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("qie8"), "ㄑㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qie9"), "ㄑㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("qie9"), "ㄑㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qif"), "ㄑㄧㄠ")
+    XCTAssertEqual(c.cS2RC("qif"), "ㄑㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qif7"), "ㄑㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("qif7"), "ㄑㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qif8"), "ㄑㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("qif8"), "ㄑㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qif9"), "ㄑㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("qif9"), "ㄑㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qiw"), "ㄑㄧㄡ")
+    XCTAssertEqual(c.cS2RC("qiw"), "ㄑㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qiw7"), "ㄑㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("qiw7"), "ㄑㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qiw8"), "ㄑㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("qiw8"), "ㄑㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qiw9"), "ㄑㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("qiw9"), "ㄑㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qim"), "ㄑㄧㄢ")
+    XCTAssertEqual(c.cS2RC("qim"), "ㄑㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qim7"), "ㄑㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("qim7"), "ㄑㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qim8"), "ㄑㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("qim8"), "ㄑㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qim9"), "ㄑㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("qim9"), "ㄑㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qin"), "ㄑㄧㄣ")
+    XCTAssertEqual(c.cS2RC("qin"), "ㄑㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qin7"), "ㄑㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("qin7"), "ㄑㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qin8"), "ㄑㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("qin8"), "ㄑㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qin9"), "ㄑㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("qin9"), "ㄑㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qik"), "ㄑㄧㄤ")
+    XCTAssertEqual(c.cS2RC("qik"), "ㄑㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qik7"), "ㄑㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("qik7"), "ㄑㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qik8"), "ㄑㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("qik8"), "ㄑㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qik9"), "ㄑㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("qik9"), "ㄑㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qig"), "ㄑㄧㄥ")
+    XCTAssertEqual(c.cS2RC("qig"), "ㄑㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qig7"), "ㄑㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("qig7"), "ㄑㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qig8"), "ㄑㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("qig8"), "ㄑㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qig9"), "ㄑㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("qig9"), "ㄑㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qv"), "ㄑㄩ")
+    XCTAssertEqual(c.cS2RC("qv"), "ㄑㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qv7"), "ㄑㄩˊ")
+    XCTAssertEqual(c.cS2RC("qv7"), "ㄑㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qv8"), "ㄑㄩˇ")
+    XCTAssertEqual(c.cS2RC("qv8"), "ㄑㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qv9"), "ㄑㄩˋ")
+    XCTAssertEqual(c.cS2RC("qv9"), "ㄑㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qve"), "ㄑㄩㄝ")
+    XCTAssertEqual(c.cS2RC("qve"), "ㄑㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qve7"), "ㄑㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("qve7"), "ㄑㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qve9"), "ㄑㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("qve9"), "ㄑㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvm"), "ㄑㄩㄢ")
+    XCTAssertEqual(c.cS2RC("qvm"), "ㄑㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvm7"), "ㄑㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("qvm7"), "ㄑㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvm8"), "ㄑㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("qvm8"), "ㄑㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvm9"), "ㄑㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("qvm9"), "ㄑㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvn"), "ㄑㄩㄣ")
+    XCTAssertEqual(c.cS2RC("qvn"), "ㄑㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvn7"), "ㄑㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("qvn7"), "ㄑㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvn8"), "ㄑㄩㄣˇ")
+    XCTAssertEqual(c.cS2RC("qvn8"), "ㄑㄩㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvn9"), "ㄑㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("qvn9"), "ㄑㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvg"), "ㄑㄩㄥ")
+    XCTAssertEqual(c.cS2RC("qvg"), "ㄑㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvg7"), "ㄑㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("qvg7"), "ㄑㄩㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvg8"), "ㄑㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("qvg8"), "ㄑㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("qvg9"), "ㄑㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("qvg9"), "ㄑㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xi"), "ㄒㄧ")
+    XCTAssertEqual(c.cS2RC("xi"), "ㄒㄧ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xi7"), "ㄒㄧˊ")
+    XCTAssertEqual(c.cS2RC("xi7"), "ㄒㄧˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xi8"), "ㄒㄧˇ")
+    XCTAssertEqual(c.cS2RC("xi8"), "ㄒㄧˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xi9"), "ㄒㄧˋ")
+    XCTAssertEqual(c.cS2RC("xi9"), "ㄒㄧˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xia"), "ㄒㄧㄚ")
+    XCTAssertEqual(c.cS2RC("xia"), "ㄒㄧㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xia7"), "ㄒㄧㄚˊ")
+    XCTAssertEqual(c.cS2RC("xia7"), "ㄒㄧㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xia8"), "ㄒㄧㄚˇ")
+    XCTAssertEqual(c.cS2RC("xia8"), "ㄒㄧㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xia9"), "ㄒㄧㄚˋ")
+    XCTAssertEqual(c.cS2RC("xia9"), "ㄒㄧㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xie"), "ㄒㄧㄝ")
+    XCTAssertEqual(c.cS2RC("xie"), "ㄒㄧㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xie7"), "ㄒㄧㄝˊ")
+    XCTAssertEqual(c.cS2RC("xie7"), "ㄒㄧㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xie8"), "ㄒㄧㄝˇ")
+    XCTAssertEqual(c.cS2RC("xie8"), "ㄒㄧㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xie9"), "ㄒㄧㄝˋ")
+    XCTAssertEqual(c.cS2RC("xie9"), "ㄒㄧㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xif"), "ㄒㄧㄠ")
+    XCTAssertEqual(c.cS2RC("xif"), "ㄒㄧㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xif7"), "ㄒㄧㄠˊ")
+    XCTAssertEqual(c.cS2RC("xif7"), "ㄒㄧㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xif8"), "ㄒㄧㄠˇ")
+    XCTAssertEqual(c.cS2RC("xif8"), "ㄒㄧㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xif9"), "ㄒㄧㄠˋ")
+    XCTAssertEqual(c.cS2RC("xif9"), "ㄒㄧㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xiw"), "ㄒㄧㄡ")
+    XCTAssertEqual(c.cS2RC("xiw"), "ㄒㄧㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xiw7"), "ㄒㄧㄡˊ")
+    XCTAssertEqual(c.cS2RC("xiw7"), "ㄒㄧㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xiw8"), "ㄒㄧㄡˇ")
+    XCTAssertEqual(c.cS2RC("xiw8"), "ㄒㄧㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xiw9"), "ㄒㄧㄡˋ")
+    XCTAssertEqual(c.cS2RC("xiw9"), "ㄒㄧㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xim"), "ㄒㄧㄢ")
+    XCTAssertEqual(c.cS2RC("xim"), "ㄒㄧㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xim7"), "ㄒㄧㄢˊ")
+    XCTAssertEqual(c.cS2RC("xim7"), "ㄒㄧㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xim8"), "ㄒㄧㄢˇ")
+    XCTAssertEqual(c.cS2RC("xim8"), "ㄒㄧㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xim9"), "ㄒㄧㄢˋ")
+    XCTAssertEqual(c.cS2RC("xim9"), "ㄒㄧㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xin"), "ㄒㄧㄣ")
+    XCTAssertEqual(c.cS2RC("xin"), "ㄒㄧㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xin7"), "ㄒㄧㄣˊ")
+    XCTAssertEqual(c.cS2RC("xin7"), "ㄒㄧㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xin8"), "ㄒㄧㄣˇ")
+    XCTAssertEqual(c.cS2RC("xin8"), "ㄒㄧㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xin9"), "ㄒㄧㄣˋ")
+    XCTAssertEqual(c.cS2RC("xin9"), "ㄒㄧㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xik"), "ㄒㄧㄤ")
+    XCTAssertEqual(c.cS2RC("xik"), "ㄒㄧㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xik7"), "ㄒㄧㄤˊ")
+    XCTAssertEqual(c.cS2RC("xik7"), "ㄒㄧㄤˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xik8"), "ㄒㄧㄤˇ")
+    XCTAssertEqual(c.cS2RC("xik8"), "ㄒㄧㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xik9"), "ㄒㄧㄤˋ")
+    XCTAssertEqual(c.cS2RC("xik9"), "ㄒㄧㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xig"), "ㄒㄧㄥ")
+    XCTAssertEqual(c.cS2RC("xig"), "ㄒㄧㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xig7"), "ㄒㄧㄥˊ")
+    XCTAssertEqual(c.cS2RC("xig7"), "ㄒㄧㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xig8"), "ㄒㄧㄥˇ")
+    XCTAssertEqual(c.cS2RC("xig8"), "ㄒㄧㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xig9"), "ㄒㄧㄥˋ")
+    XCTAssertEqual(c.cS2RC("xig9"), "ㄒㄧㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xv"), "ㄒㄩ")
+    XCTAssertEqual(c.cS2RC("xv"), "ㄒㄩ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xv7"), "ㄒㄩˊ")
+    XCTAssertEqual(c.cS2RC("xv7"), "ㄒㄩˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xv8"), "ㄒㄩˇ")
+    XCTAssertEqual(c.cS2RC("xv8"), "ㄒㄩˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xv9"), "ㄒㄩˋ")
+    XCTAssertEqual(c.cS2RC("xv9"), "ㄒㄩˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xve"), "ㄒㄩㄝ")
+    XCTAssertEqual(c.cS2RC("xve"), "ㄒㄩㄝ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xve7"), "ㄒㄩㄝˊ")
+    XCTAssertEqual(c.cS2RC("xve7"), "ㄒㄩㄝˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xve8"), "ㄒㄩㄝˇ")
+    XCTAssertEqual(c.cS2RC("xve8"), "ㄒㄩㄝˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xve9"), "ㄒㄩㄝˋ")
+    XCTAssertEqual(c.cS2RC("xve9"), "ㄒㄩㄝˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvm"), "ㄒㄩㄢ")
+    XCTAssertEqual(c.cS2RC("xvm"), "ㄒㄩㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvm7"), "ㄒㄩㄢˊ")
+    XCTAssertEqual(c.cS2RC("xvm7"), "ㄒㄩㄢˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvm8"), "ㄒㄩㄢˇ")
+    XCTAssertEqual(c.cS2RC("xvm8"), "ㄒㄩㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvm9"), "ㄒㄩㄢˋ")
+    XCTAssertEqual(c.cS2RC("xvm9"), "ㄒㄩㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvn"), "ㄒㄩㄣ")
+    XCTAssertEqual(c.cS2RC("xvn"), "ㄒㄩㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvn7"), "ㄒㄩㄣˊ")
+    XCTAssertEqual(c.cS2RC("xvn7"), "ㄒㄩㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvn9"), "ㄒㄩㄣˋ")
+    XCTAssertEqual(c.cS2RC("xvn9"), "ㄒㄩㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvg"), "ㄒㄩㄥ")
+    XCTAssertEqual(c.cS2RC("xvg"), "ㄒㄩㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvg7"), "ㄒㄩㄥˊ")
+    XCTAssertEqual(c.cS2RC("xvg7"), "ㄒㄩㄥˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvg8"), "ㄒㄩㄥˇ")
+    XCTAssertEqual(c.cS2RC("xvg8"), "ㄒㄩㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("xvg9"), "ㄒㄩㄥˋ")
+    XCTAssertEqual(c.cS2RC("xvg9"), "ㄒㄩㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("j"), "ㄓ")
+    XCTAssertEqual(c.cS2RC("j"), "ㄓ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("j7"), "ㄓˊ")
+    XCTAssertEqual(c.cS2RC("j7"), "ㄓˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("j8"), "ㄓˇ")
+    XCTAssertEqual(c.cS2RC("j8"), "ㄓˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("j9"), "ㄓˋ")
+    XCTAssertEqual(c.cS2RC("j9"), "ㄓˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ja"), "ㄓㄚ")
+    XCTAssertEqual(c.cS2RC("ja"), "ㄓㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ja7"), "ㄓㄚˊ")
+    XCTAssertEqual(c.cS2RC("ja7"), "ㄓㄚˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ja8"), "ㄓㄚˇ")
+    XCTAssertEqual(c.cS2RC("ja8"), "ㄓㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ja9"), "ㄓㄚˋ")
+    XCTAssertEqual(c.cS2RC("ja9"), "ㄓㄚˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("je"), "ㄓㄜ")
+    XCTAssertEqual(c.cS2RC("je"), "ㄓㄜ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("je7"), "ㄓㄜˊ")
+    XCTAssertEqual(c.cS2RC("je7"), "ㄓㄜˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("je8"), "ㄓㄜˇ")
+    XCTAssertEqual(c.cS2RC("je8"), "ㄓㄜˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("je9"), "ㄓㄜˋ")
+    XCTAssertEqual(c.cS2RC("je9"), "ㄓㄜˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("je0"), "ㄓㄜ˙")
+    XCTAssertEqual(c.cS2RC("je0"), "ㄓㄜ˙")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jy"), "ㄓㄞ")
+    XCTAssertEqual(c.cS2RC("jy"), "ㄓㄞ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jy7"), "ㄓㄞˊ")
+    XCTAssertEqual(c.cS2RC("jy7"), "ㄓㄞˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jy8"), "ㄓㄞˇ")
+    XCTAssertEqual(c.cS2RC("jy8"), "ㄓㄞˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jy9"), "ㄓㄞˋ")
+    XCTAssertEqual(c.cS2RC("jy9"), "ㄓㄞˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jt9"), "ㄓㄟˋ")
+    XCTAssertEqual(c.cS2RC("jt9"), "ㄓㄟˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jf"), "ㄓㄠ")
+    XCTAssertEqual(c.cS2RC("jf"), "ㄓㄠ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jf7"), "ㄓㄠˊ")
+    XCTAssertEqual(c.cS2RC("jf7"), "ㄓㄠˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jf8"), "ㄓㄠˇ")
+    XCTAssertEqual(c.cS2RC("jf8"), "ㄓㄠˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jf9"), "ㄓㄠˋ")
+    XCTAssertEqual(c.cS2RC("jf9"), "ㄓㄠˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jw"), "ㄓㄡ")
+    XCTAssertEqual(c.cS2RC("jw"), "ㄓㄡ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jw7"), "ㄓㄡˊ")
+    XCTAssertEqual(c.cS2RC("jw7"), "ㄓㄡˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jw8"), "ㄓㄡˇ")
+    XCTAssertEqual(c.cS2RC("jw8"), "ㄓㄡˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jw9"), "ㄓㄡˋ")
+    XCTAssertEqual(c.cS2RC("jw9"), "ㄓㄡˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jm"), "ㄓㄢ")
+    XCTAssertEqual(c.cS2RC("jm"), "ㄓㄢ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jm8"), "ㄓㄢˇ")
+    XCTAssertEqual(c.cS2RC("jm8"), "ㄓㄢˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jm9"), "ㄓㄢˋ")
+    XCTAssertEqual(c.cS2RC("jm9"), "ㄓㄢˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jn"), "ㄓㄣ")
+    XCTAssertEqual(c.cS2RC("jn"), "ㄓㄣ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jn7"), "ㄓㄣˊ")
+    XCTAssertEqual(c.cS2RC("jn7"), "ㄓㄣˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jn8"), "ㄓㄣˇ")
+    XCTAssertEqual(c.cS2RC("jn8"), "ㄓㄣˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jn9"), "ㄓㄣˋ")
+    XCTAssertEqual(c.cS2RC("jn9"), "ㄓㄣˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jk"), "ㄓㄤ")
+    XCTAssertEqual(c.cS2RC("jk"), "ㄓㄤ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jk8"), "ㄓㄤˇ")
+    XCTAssertEqual(c.cS2RC("jk8"), "ㄓㄤˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jk9"), "ㄓㄤˋ")
+    XCTAssertEqual(c.cS2RC("jk9"), "ㄓㄤˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jg"), "ㄓㄥ")
+    XCTAssertEqual(c.cS2RC("jg"), "ㄓㄥ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jg8"), "ㄓㄥˇ")
+    XCTAssertEqual(c.cS2RC("jg8"), "ㄓㄥˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jg9"), "ㄓㄥˋ")
+    XCTAssertEqual(c.cS2RC("jg9"), "ㄓㄥˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ju"), "ㄓㄨ")
+    XCTAssertEqual(c.cS2RC("ju"), "ㄓㄨ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ju7"), "ㄓㄨˊ")
+    XCTAssertEqual(c.cS2RC("ju7"), "ㄓㄨˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ju8"), "ㄓㄨˇ")
+    XCTAssertEqual(c.cS2RC("ju8"), "ㄓㄨˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("ju9"), "ㄓㄨˋ")
+    XCTAssertEqual(c.cS2RC("ju9"), "ㄓㄨˋ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jua"), "ㄓㄨㄚ")
+    XCTAssertEqual(c.cS2RC("jua"), "ㄓㄨㄚ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("jua8"), "ㄓㄨㄚˇ")
+    XCTAssertEqual(c.cS2RC("jua8"), "ㄓㄨㄚˇ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("juo"), "ㄓㄨㄛ")
+    XCTAssertEqual(c.cS2RC("juo"), "ㄓㄨㄛ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("juo7"), "ㄓㄨㄛˊ")
+    XCTAssertEqual(c.cS2RC("juo7"), "ㄓㄨㄛˊ")
-    XCTAssertEqual(composer.convertSequenceToRawComposition("juo9"), "ㄓㄨㄛˋ")
+    XCTAssertEqual(c.cS2RC("juo9"), "ㄓㄨㄛˋ")
   }
 }