ShikiSuen/A-OVMANDARIN-UNITTEST.MD

## A-OVMANDARIN-UNITTEST.MD

      
    Raw
  

              A-OVMANDARIN-UNITTEST.MD
            
          
    該測試為窮極測試，測試盡可能所有的在理論上能用倚天26與許氏鍵盤輸入的注音組合。
在執行此測試之前，請在 Mandarin.h 的接近檔案末尾的位置新增如下圖選中區域的內容：

也就是在 BopomofoReadingBuffer 的 public 段新增：
  std::string cnvSequence(std::string givenSequence) {
    clear();
    for (char key : givenSequence) {
      combineKey(key);
    }
    return composedString();
  };
咱們用 Mandarin 隨贈的 Google Test、可以讓測試得以正常進行。相關檔案在此。Cpp 結尾的測試檔案是給 Google Test 用的；以「.mm」結尾的檔案是給 Xcode Test 用的。所有檔案必須得是 UTF8 無 BOM 的格式，否則測試會出錯。
可以的話，最好還是用 Xcode Test，畢竟可以一次性告訴你全部的出錯的地方。Google Test 測試結果只要有一處出錯，之後的測試點的內容就沒再測試了，不太方便就所有測試條目的的錯誤結果進行綜合分析。鐵恨注拼引擎正是受益於 Xcode Test 的這個特性、才能迅速完成與許氏鍵盤和倚天26鍵有關的處理函式的排障工作。
測試結果：OVMandarin 除了無法讓倚天26與許氏鍵盤處理「ㄑ˙」這個讀音以外，其餘一切正常。

  
## MandarinTest.cpp
// This test file is written by Shiki Suen (MIT License).
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

#include "Mandarin.h"
#include "gtest/gtest.h"

namespace Formosa {
namespace Mandarin {

// ====== ADVANCED TESTS ======

TEST(MandarinTestAdvanced, DachenTraditional) {
  BopomofoReadingBuffer composer(BopomofoKeyboardLayout::StandardLayout());
  ASSERT_EQ(composer.cnvSequence("18"), "ㄅㄚ");
  ASSERT_EQ(composer.cnvSequence("m,4"), "ㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("5j/"), "ㄓㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("fu."), "ㄑㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("g0"), "ㄕㄢ");
  ASSERT_EQ(composer.cnvSequence("xup6"), "ㄌㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("xu;6"), "ㄌㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("z/"), "ㄈㄥ");
  ASSERT_EQ(composer.cnvSequence("tjo"), "ㄔㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("284"), "ㄉㄚˋ");
  ASSERT_EQ(composer.cnvSequence("2u4"), "ㄉㄧˋ");
  ASSERT_EQ(composer.cnvSequence("hl3"), "ㄘㄠˇ");
  ASSERT_EQ(composer.cnvSequence("5"), "ㄓ");
  ASSERT_EQ(composer.cnvSequence("193"), "ㄅㄞˇ");
}
TEST(MandarinTestAdvanced, Eten26) {
  // 倚天26窮極測試;
  BopomofoReadingBuffer composer(BopomofoKeyboardLayout::ETen26Layout());
  ASSERT_EQ(composer.cnvSequence("ket"), "ㄎㄧㄤ");
  // AreEqual(Composer.cnvSequence("vezf"), "ㄍㄧㄠˊ");
  // AreEqual(Composer.cnvSequence("ven"), "ㄍㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("betf"), "ㄅㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("betk"), "ㄅㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("dxt"), "ㄉㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("ba"), "ㄅㄚ");
  ASSERT_EQ(composer.cnvSequence("baf"), "ㄅㄚˊ");
  ASSERT_EQ(composer.cnvSequence("baj"), "ㄅㄚˇ");
  ASSERT_EQ(composer.cnvSequence("bak"), "ㄅㄚˋ");
  ASSERT_EQ(composer.cnvSequence("bad"), "ㄅㄚ˙");
  ASSERT_EQ(composer.cnvSequence("bo"), "ㄅㄛ");
  ASSERT_EQ(composer.cnvSequence("bof"), "ㄅㄛˊ");
  ASSERT_EQ(composer.cnvSequence("boj"), "ㄅㄛˇ");
  ASSERT_EQ(composer.cnvSequence("bok"), "ㄅㄛˋ");
  ASSERT_EQ(composer.cnvSequence("bod"), "ㄅㄛ˙");
  ASSERT_EQ(composer.cnvSequence("bi"), "ㄅㄞ");
  ASSERT_EQ(composer.cnvSequence("bif"), "ㄅㄞˊ");
  ASSERT_EQ(composer.cnvSequence("bij"), "ㄅㄞˇ");
  ASSERT_EQ(composer.cnvSequence("bik"), "ㄅㄞˋ");
  ASSERT_EQ(composer.cnvSequence("bid"), "ㄅㄞ˙");
  ASSERT_EQ(composer.cnvSequence("bq"), "ㄅㄟ");
  ASSERT_EQ(composer.cnvSequence("bqj"), "ㄅㄟˇ");
  ASSERT_EQ(composer.cnvSequence("bqk"), "ㄅㄟˋ");
  ASSERT_EQ(composer.cnvSequence("bqd"), "ㄅㄟ˙");
  ASSERT_EQ(composer.cnvSequence("bz"), "ㄅㄠ");
  ASSERT_EQ(composer.cnvSequence("bzf"), "ㄅㄠˊ");
  ASSERT_EQ(composer.cnvSequence("bzj"), "ㄅㄠˇ");
  ASSERT_EQ(composer.cnvSequence("bzk"), "ㄅㄠˋ");
  ASSERT_EQ(composer.cnvSequence("bm"), "ㄅㄢ");
  ASSERT_EQ(composer.cnvSequence("bmj"), "ㄅㄢˇ");
  ASSERT_EQ(composer.cnvSequence("bmk"), "ㄅㄢˋ");
  ASSERT_EQ(composer.cnvSequence("bn"), "ㄅㄣ");
  ASSERT_EQ(composer.cnvSequence("bnj"), "ㄅㄣˇ");
  ASSERT_EQ(composer.cnvSequence("bnk"), "ㄅㄣˋ");
  ASSERT_EQ(composer.cnvSequence("bt"), "ㄅㄤ");
  ASSERT_EQ(composer.cnvSequence("btj"), "ㄅㄤˇ");
  ASSERT_EQ(composer.cnvSequence("btk"), "ㄅㄤˋ");
  ASSERT_EQ(composer.cnvSequence("bl"), "ㄅㄥ");
  ASSERT_EQ(composer.cnvSequence("blf"), "ㄅㄥˊ");
  ASSERT_EQ(composer.cnvSequence("blj"), "ㄅㄥˇ");
  ASSERT_EQ(composer.cnvSequence("blk"), "ㄅㄥˋ");
  ASSERT_EQ(composer.cnvSequence("be"), "ㄅㄧ");
  ASSERT_EQ(composer.cnvSequence("bef"), "ㄅㄧˊ");
  ASSERT_EQ(composer.cnvSequence("bej"), "ㄅㄧˇ");
  ASSERT_EQ(composer.cnvSequence("bek"), "ㄅㄧˋ");
  ASSERT_EQ(composer.cnvSequence("bew"), "ㄅㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("bewf"), "ㄅㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("bewj"), "ㄅㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("bewk"), "ㄅㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("bez"), "ㄅㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("bezj"), "ㄅㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("bezk"), "ㄅㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("bem"), "ㄅㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("bemf"), "ㄅㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("bemj"), "ㄅㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("bemk"), "ㄅㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("ben"), "ㄅㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("benj"), "ㄅㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("benk"), "ㄅㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("bel"), "ㄅㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("belj"), "ㄅㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("belk"), "ㄅㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("bx"), "ㄅㄨ");
  ASSERT_EQ(composer.cnvSequence("bxf"), "ㄅㄨˊ");
  ASSERT_EQ(composer.cnvSequence("bxj"), "ㄅㄨˇ");
  ASSERT_EQ(composer.cnvSequence("bxk"), "ㄅㄨˋ");
  ASSERT_EQ(composer.cnvSequence("pa"), "ㄆㄚ");
  ASSERT_EQ(composer.cnvSequence("paf"), "ㄆㄚˊ");
  ASSERT_EQ(composer.cnvSequence("paj"), "ㄆㄚˇ");
  ASSERT_EQ(composer.cnvSequence("pak"), "ㄆㄚˋ");
  ASSERT_EQ(composer.cnvSequence("pad"), "ㄆㄚ˙");
  ASSERT_EQ(composer.cnvSequence("po"), "ㄆㄛ");
  ASSERT_EQ(composer.cnvSequence("pof"), "ㄆㄛˊ");
  ASSERT_EQ(composer.cnvSequence("poj"), "ㄆㄛˇ");
  ASSERT_EQ(composer.cnvSequence("pok"), "ㄆㄛˋ");
  ASSERT_EQ(composer.cnvSequence("pi"), "ㄆㄞ");
  ASSERT_EQ(composer.cnvSequence("pif"), "ㄆㄞˊ");
  ASSERT_EQ(composer.cnvSequence("pij"), "ㄆㄞˇ");
  ASSERT_EQ(composer.cnvSequence("pik"), "ㄆㄞˋ");
  ASSERT_EQ(composer.cnvSequence("pq"), "ㄆㄟ");
  ASSERT_EQ(composer.cnvSequence("pqf"), "ㄆㄟˊ");
  ASSERT_EQ(composer.cnvSequence("pqj"), "ㄆㄟˇ");
  ASSERT_EQ(composer.cnvSequence("pqk"), "ㄆㄟˋ");
  ASSERT_EQ(composer.cnvSequence("pz"), "ㄆㄠ");
  ASSERT_EQ(composer.cnvSequence("pzf"), "ㄆㄠˊ");
  ASSERT_EQ(composer.cnvSequence("pzj"), "ㄆㄠˇ");
  ASSERT_EQ(composer.cnvSequence("pzk"), "ㄆㄠˋ");
  ASSERT_EQ(composer.cnvSequence("pp"), "ㄆㄡ");
  ASSERT_EQ(composer.cnvSequence("ppf"), "ㄆㄡˊ");
  ASSERT_EQ(composer.cnvSequence("ppj"), "ㄆㄡˇ");
  ASSERT_EQ(composer.cnvSequence("ppk"), "ㄆㄡˋ");
  ASSERT_EQ(composer.cnvSequence("pm"), "ㄆㄢ");
  ASSERT_EQ(composer.cnvSequence("pmf"), "ㄆㄢˊ");
  ASSERT_EQ(composer.cnvSequence("pmj"), "ㄆㄢˇ");
  ASSERT_EQ(composer.cnvSequence("pmk"), "ㄆㄢˋ");
  ASSERT_EQ(composer.cnvSequence("pn"), "ㄆㄣ");
  ASSERT_EQ(composer.cnvSequence("pnf"), "ㄆㄣˊ");
  ASSERT_EQ(composer.cnvSequence("pnj"), "ㄆㄣˇ");
  ASSERT_EQ(composer.cnvSequence("pnk"), "ㄆㄣˋ");
  ASSERT_EQ(composer.cnvSequence("pt"), "ㄆㄤ");
  ASSERT_EQ(composer.cnvSequence("ptf"), "ㄆㄤˊ");
  ASSERT_EQ(composer.cnvSequence("ptj"), "ㄆㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ptk"), "ㄆㄤˋ");
  ASSERT_EQ(composer.cnvSequence("pl"), "ㄆㄥ");
  ASSERT_EQ(composer.cnvSequence("plf"), "ㄆㄥˊ");
  ASSERT_EQ(composer.cnvSequence("plj"), "ㄆㄥˇ");
  ASSERT_EQ(composer.cnvSequence("plk"), "ㄆㄥˋ");
  ASSERT_EQ(composer.cnvSequence("pe"), "ㄆㄧ");
  ASSERT_EQ(composer.cnvSequence("pef"), "ㄆㄧˊ");
  ASSERT_EQ(composer.cnvSequence("pej"), "ㄆㄧˇ");
  ASSERT_EQ(composer.cnvSequence("pek"), "ㄆㄧˋ");
  ASSERT_EQ(composer.cnvSequence("pea"), "ㄆㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("pew"), "ㄆㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("pewj"), "ㄆㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("pewk"), "ㄆㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("pez"), "ㄆㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("pezf"), "ㄆㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("pezj"), "ㄆㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("pezk"), "ㄆㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("pem"), "ㄆㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("pemf"), "ㄆㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("pemj"), "ㄆㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("pemk"), "ㄆㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("pen"), "ㄆㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("penf"), "ㄆㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("penj"), "ㄆㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("penk"), "ㄆㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("pel"), "ㄆㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("pelf"), "ㄆㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("pelj"), "ㄆㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("pelk"), "ㄆㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("px"), "ㄆㄨ");
  ASSERT_EQ(composer.cnvSequence("pxf"), "ㄆㄨˊ");
  ASSERT_EQ(composer.cnvSequence("pxj"), "ㄆㄨˇ");
  ASSERT_EQ(composer.cnvSequence("pxk"), "ㄆㄨˋ");
  ASSERT_EQ(composer.cnvSequence("ma"), "ㄇㄚ");
  ASSERT_EQ(composer.cnvSequence("maf"), "ㄇㄚˊ");
  ASSERT_EQ(composer.cnvSequence("maj"), "ㄇㄚˇ");
  ASSERT_EQ(composer.cnvSequence("mak"), "ㄇㄚˋ");
  ASSERT_EQ(composer.cnvSequence("mad"), "ㄇㄚ˙");
  ASSERT_EQ(composer.cnvSequence("mo"), "ㄇㄛ");
  ASSERT_EQ(composer.cnvSequence("mof"), "ㄇㄛˊ");
  ASSERT_EQ(composer.cnvSequence("moj"), "ㄇㄛˇ");
  ASSERT_EQ(composer.cnvSequence("mok"), "ㄇㄛˋ");
  ASSERT_EQ(composer.cnvSequence("mod"), "ㄇㄛ˙");
  ASSERT_EQ(composer.cnvSequence("mr"), "ㄇㄜ");
  ASSERT_EQ(composer.cnvSequence("mrk"), "ㄇㄜˋ");
  ASSERT_EQ(composer.cnvSequence("mrd"), "ㄇㄜ˙");
  ASSERT_EQ(composer.cnvSequence("mi"), "ㄇㄞ");
  ASSERT_EQ(composer.cnvSequence("mif"), "ㄇㄞˊ");
  ASSERT_EQ(composer.cnvSequence("mij"), "ㄇㄞˇ");
  ASSERT_EQ(composer.cnvSequence("mik"), "ㄇㄞˋ");
  ASSERT_EQ(composer.cnvSequence("mqf"), "ㄇㄟˊ");
  ASSERT_EQ(composer.cnvSequence("mqj"), "ㄇㄟˇ");
  ASSERT_EQ(composer.cnvSequence("mqk"), "ㄇㄟˋ");
  ASSERT_EQ(composer.cnvSequence("mz"), "ㄇㄠ");
  ASSERT_EQ(composer.cnvSequence("mzf"), "ㄇㄠˊ");
  ASSERT_EQ(composer.cnvSequence("mzj"), "ㄇㄠˇ");
  ASSERT_EQ(composer.cnvSequence("mzk"), "ㄇㄠˋ");
  ASSERT_EQ(composer.cnvSequence("mpf"), "ㄇㄡˊ");
  ASSERT_EQ(composer.cnvSequence("mpj"), "ㄇㄡˇ");
  ASSERT_EQ(composer.cnvSequence("mpk"), "ㄇㄡˋ");
  ASSERT_EQ(composer.cnvSequence("mm"), "ㄇㄢ");
  ASSERT_EQ(composer.cnvSequence("mmf"), "ㄇㄢˊ");
  ASSERT_EQ(composer.cnvSequence("mmj"), "ㄇㄢˇ");
  ASSERT_EQ(composer.cnvSequence("mmk"), "ㄇㄢˋ");
  ASSERT_EQ(composer.cnvSequence("mn"), "ㄇㄣ");
  ASSERT_EQ(composer.cnvSequence("mnf"), "ㄇㄣˊ");
  ASSERT_EQ(composer.cnvSequence("mnj"), "ㄇㄣˇ");
  ASSERT_EQ(composer.cnvSequence("mnk"), "ㄇㄣˋ");
  ASSERT_EQ(composer.cnvSequence("mnd"), "ㄇㄣ˙");
  ASSERT_EQ(composer.cnvSequence("mt"), "ㄇㄤ");
  ASSERT_EQ(composer.cnvSequence("mtf"), "ㄇㄤˊ");
  ASSERT_EQ(composer.cnvSequence("mtj"), "ㄇㄤˇ");
  ASSERT_EQ(composer.cnvSequence("mtk"), "ㄇㄤˋ");
  ASSERT_EQ(composer.cnvSequence("ml"), "ㄇㄥ");
  ASSERT_EQ(composer.cnvSequence("mlf"), "ㄇㄥˊ");
  ASSERT_EQ(composer.cnvSequence("mlj"), "ㄇㄥˇ");
  ASSERT_EQ(composer.cnvSequence("mlk"), "ㄇㄥˋ");
  ASSERT_EQ(composer.cnvSequence("me"), "ㄇㄧ");
  ASSERT_EQ(composer.cnvSequence("mef"), "ㄇㄧˊ");
  ASSERT_EQ(composer.cnvSequence("mej"), "ㄇㄧˇ");
  ASSERT_EQ(composer.cnvSequence("mek"), "ㄇㄧˋ");
  ASSERT_EQ(composer.cnvSequence("mew"), "ㄇㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("mewf"), "ㄇㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("mewk"), "ㄇㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("mez"), "ㄇㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("mezf"), "ㄇㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("mezj"), "ㄇㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("mezk"), "ㄇㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("mepf"), "ㄇㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("mepj"), "ㄇㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("mepk"), "ㄇㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("mem"), "ㄇㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("memf"), "ㄇㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("memj"), "ㄇㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("memk"), "ㄇㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("men"), "ㄇㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("menf"), "ㄇㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("menj"), "ㄇㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("melf"), "ㄇㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("melj"), "ㄇㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("melk"), "ㄇㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("mxf"), "ㄇㄨˊ");
  ASSERT_EQ(composer.cnvSequence("mxj"), "ㄇㄨˇ");
  ASSERT_EQ(composer.cnvSequence("mxk"), "ㄇㄨˋ");
  ASSERT_EQ(composer.cnvSequence("fa"), "ㄈㄚ");
  ASSERT_EQ(composer.cnvSequence("faf"), "ㄈㄚˊ");
  ASSERT_EQ(composer.cnvSequence("faj"), "ㄈㄚˇ");
  ASSERT_EQ(composer.cnvSequence("fak"), "ㄈㄚˋ");
  ASSERT_EQ(composer.cnvSequence("fof"), "ㄈㄛˊ");
  ASSERT_EQ(composer.cnvSequence("fq"), "ㄈㄟ");
  ASSERT_EQ(composer.cnvSequence("fqf"), "ㄈㄟˊ");
  ASSERT_EQ(composer.cnvSequence("fqj"), "ㄈㄟˇ");
  ASSERT_EQ(composer.cnvSequence("fqk"), "ㄈㄟˋ");
  ASSERT_EQ(composer.cnvSequence("fp"), "ㄈㄡ");
  ASSERT_EQ(composer.cnvSequence("fpf"), "ㄈㄡˊ");
  ASSERT_EQ(composer.cnvSequence("fpj"), "ㄈㄡˇ");
  ASSERT_EQ(composer.cnvSequence("fpk"), "ㄈㄡˋ");
  ASSERT_EQ(composer.cnvSequence("fm"), "ㄈㄢ");
  ASSERT_EQ(composer.cnvSequence("fmf"), "ㄈㄢˊ");
  ASSERT_EQ(composer.cnvSequence("fmj"), "ㄈㄢˇ");
  ASSERT_EQ(composer.cnvSequence("fmk"), "ㄈㄢˋ");
  ASSERT_EQ(composer.cnvSequence("fn"), "ㄈㄣ");
  ASSERT_EQ(composer.cnvSequence("fnf"), "ㄈㄣˊ");
  ASSERT_EQ(composer.cnvSequence("fnj"), "ㄈㄣˇ");
  ASSERT_EQ(composer.cnvSequence("fnk"), "ㄈㄣˋ");
  ASSERT_EQ(composer.cnvSequence("fnd"), "ㄈㄣ˙");
  ASSERT_EQ(composer.cnvSequence("ft"), "ㄈㄤ");
  ASSERT_EQ(composer.cnvSequence("ftf"), "ㄈㄤˊ");
  ASSERT_EQ(composer.cnvSequence("ftj"), "ㄈㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ftk"), "ㄈㄤˋ");
  ASSERT_EQ(composer.cnvSequence("fl"), "ㄈㄥ");
  ASSERT_EQ(composer.cnvSequence("flf"), "ㄈㄥˊ");
  ASSERT_EQ(composer.cnvSequence("flj"), "ㄈㄥˇ");
  ASSERT_EQ(composer.cnvSequence("flk"), "ㄈㄥˋ");
  ASSERT_EQ(composer.cnvSequence("fezk"), "ㄈㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("fx"), "ㄈㄨ");
  ASSERT_EQ(composer.cnvSequence("fxf"), "ㄈㄨˊ");
  ASSERT_EQ(composer.cnvSequence("fxj"), "ㄈㄨˇ");
  ASSERT_EQ(composer.cnvSequence("fxk"), "ㄈㄨˋ");
  ASSERT_EQ(composer.cnvSequence("da"), "ㄉㄚ");
  ASSERT_EQ(composer.cnvSequence("daf"), "ㄉㄚˊ");
  ASSERT_EQ(composer.cnvSequence("daj"), "ㄉㄚˇ");
  ASSERT_EQ(composer.cnvSequence("dak"), "ㄉㄚˋ");
  ASSERT_EQ(composer.cnvSequence("dad"), "ㄉㄚ˙");
  ASSERT_EQ(composer.cnvSequence("dr"), "ㄉㄜ");
  ASSERT_EQ(composer.cnvSequence("drf"), "ㄉㄜˊ");
  ASSERT_EQ(composer.cnvSequence("drd"), "ㄉㄜ˙");
  ASSERT_EQ(composer.cnvSequence("di"), "ㄉㄞ");
  ASSERT_EQ(composer.cnvSequence("dij"), "ㄉㄞˇ");
  ASSERT_EQ(composer.cnvSequence("dik"), "ㄉㄞˋ");
  ASSERT_EQ(composer.cnvSequence("dqj"), "ㄉㄟˇ");
  ASSERT_EQ(composer.cnvSequence("dz"), "ㄉㄠ");
  ASSERT_EQ(composer.cnvSequence("dzf"), "ㄉㄠˊ");
  ASSERT_EQ(composer.cnvSequence("dzj"), "ㄉㄠˇ");
  ASSERT_EQ(composer.cnvSequence("dzk"), "ㄉㄠˋ");
  ASSERT_EQ(composer.cnvSequence("dp"), "ㄉㄡ");
  ASSERT_EQ(composer.cnvSequence("dpf"), "ㄉㄡˊ");
  ASSERT_EQ(composer.cnvSequence("dpj"), "ㄉㄡˇ");
  ASSERT_EQ(composer.cnvSequence("dpk"), "ㄉㄡˋ");
  ASSERT_EQ(composer.cnvSequence("dm"), "ㄉㄢ");
  ASSERT_EQ(composer.cnvSequence("dmj"), "ㄉㄢˇ");
  ASSERT_EQ(composer.cnvSequence("dmk"), "ㄉㄢˋ");
  ASSERT_EQ(composer.cnvSequence("dnk"), "ㄉㄣˋ");
  ASSERT_EQ(composer.cnvSequence("dt"), "ㄉㄤ");
  ASSERT_EQ(composer.cnvSequence("dtj"), "ㄉㄤˇ");
  ASSERT_EQ(composer.cnvSequence("dtk"), "ㄉㄤˋ");
  ASSERT_EQ(composer.cnvSequence("dl"), "ㄉㄥ");
  ASSERT_EQ(composer.cnvSequence("dlj"), "ㄉㄥˇ");
  ASSERT_EQ(composer.cnvSequence("dlk"), "ㄉㄥˋ");
  ASSERT_EQ(composer.cnvSequence("de"), "ㄉㄧ");
  ASSERT_EQ(composer.cnvSequence("def"), "ㄉㄧˊ");
  ASSERT_EQ(composer.cnvSequence("dej"), "ㄉㄧˇ");
  ASSERT_EQ(composer.cnvSequence("dek"), "ㄉㄧˋ");
  ASSERT_EQ(composer.cnvSequence("deaj"), "ㄉㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("dew"), "ㄉㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("dewf"), "ㄉㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("dewj"), "ㄉㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("dewk"), "ㄉㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("dez"), "ㄉㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("dezj"), "ㄉㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("dezk"), "ㄉㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("dep"), "ㄉㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("dem"), "ㄉㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("demf"), "ㄉㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("demj"), "ㄉㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("demk"), "ㄉㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("del"), "ㄉㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("delf"), "ㄉㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("delj"), "ㄉㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("delk"), "ㄉㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("dx"), "ㄉㄨ");
  ASSERT_EQ(composer.cnvSequence("dxf"), "ㄉㄨˊ");
  ASSERT_EQ(composer.cnvSequence("dxj"), "ㄉㄨˇ");
  ASSERT_EQ(composer.cnvSequence("dxk"), "ㄉㄨˋ");
  ASSERT_EQ(composer.cnvSequence("dxo"), "ㄉㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("dxof"), "ㄉㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("dxoj"), "ㄉㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("dxok"), "ㄉㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("dxod"), "ㄉㄨㄛ˙");
  ASSERT_EQ(composer.cnvSequence("dxq"), "ㄉㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("dxqj"), "ㄉㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("dxqk"), "ㄉㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("dxm"), "ㄉㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("dxmj"), "ㄉㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("dxmk"), "ㄉㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("dxn"), "ㄉㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("dxnj"), "ㄉㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("dxnk"), "ㄉㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("dxl"), "ㄉㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("dxlj"), "ㄉㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("dxlk"), "ㄉㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ta"), "ㄊㄚ");
  ASSERT_EQ(composer.cnvSequence("taj"), "ㄊㄚˇ");
  ASSERT_EQ(composer.cnvSequence("tak"), "ㄊㄚˋ");
  ASSERT_EQ(composer.cnvSequence("trk"), "ㄊㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ti"), "ㄊㄞ");
  ASSERT_EQ(composer.cnvSequence("tif"), "ㄊㄞˊ");
  ASSERT_EQ(composer.cnvSequence("tij"), "ㄊㄞˇ");
  ASSERT_EQ(composer.cnvSequence("tik"), "ㄊㄞˋ");
  ASSERT_EQ(composer.cnvSequence("tid"), "ㄊㄞ˙");
  ASSERT_EQ(composer.cnvSequence("tz"), "ㄊㄠ");
  ASSERT_EQ(composer.cnvSequence("tzf"), "ㄊㄠˊ");
  ASSERT_EQ(composer.cnvSequence("tzj"), "ㄊㄠˇ");
  ASSERT_EQ(composer.cnvSequence("tzk"), "ㄊㄠˋ");
  ASSERT_EQ(composer.cnvSequence("tzd"), "ㄊㄠ˙");
  ASSERT_EQ(composer.cnvSequence("tp"), "ㄊㄡ");
  ASSERT_EQ(composer.cnvSequence("tpf"), "ㄊㄡˊ");
  ASSERT_EQ(composer.cnvSequence("tpj"), "ㄊㄡˇ");
  ASSERT_EQ(composer.cnvSequence("tpk"), "ㄊㄡˋ");
  ASSERT_EQ(composer.cnvSequence("tpd"), "ㄊㄡ˙");
  ASSERT_EQ(composer.cnvSequence("tm"), "ㄊㄢ");
  ASSERT_EQ(composer.cnvSequence("tmf"), "ㄊㄢˊ");
  ASSERT_EQ(composer.cnvSequence("tmj"), "ㄊㄢˇ");
  ASSERT_EQ(composer.cnvSequence("tmk"), "ㄊㄢˋ");
  ASSERT_EQ(composer.cnvSequence("tt"), "ㄊㄤ");
  ASSERT_EQ(composer.cnvSequence("ttf"), "ㄊㄤˊ");
  ASSERT_EQ(composer.cnvSequence("ttj"), "ㄊㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ttk"), "ㄊㄤˋ");
  ASSERT_EQ(composer.cnvSequence("tl"), "ㄊㄥ");
  ASSERT_EQ(composer.cnvSequence("tlf"), "ㄊㄥˊ");
  ASSERT_EQ(composer.cnvSequence("tlk"), "ㄊㄥˋ");
  ASSERT_EQ(composer.cnvSequence("te"), "ㄊㄧ");
  ASSERT_EQ(composer.cnvSequence("tef"), "ㄊㄧˊ");
  ASSERT_EQ(composer.cnvSequence("tej"), "ㄊㄧˇ");
  ASSERT_EQ(composer.cnvSequence("tek"), "ㄊㄧˋ");
  ASSERT_EQ(composer.cnvSequence("tew"), "ㄊㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("tewf"), "ㄊㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("tewj"), "ㄊㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("tewk"), "ㄊㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("tez"), "ㄊㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("tezf"), "ㄊㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("tezj"), "ㄊㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("tezk"), "ㄊㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("tem"), "ㄊㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("temf"), "ㄊㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("temj"), "ㄊㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("temk"), "ㄊㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("tel"), "ㄊㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("telf"), "ㄊㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("telj"), "ㄊㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("telk"), "ㄊㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("tx"), "ㄊㄨ");
  ASSERT_EQ(composer.cnvSequence("txf"), "ㄊㄨˊ");
  ASSERT_EQ(composer.cnvSequence("txj"), "ㄊㄨˇ");
  ASSERT_EQ(composer.cnvSequence("txk"), "ㄊㄨˋ");
  ASSERT_EQ(composer.cnvSequence("txo"), "ㄊㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("txof"), "ㄊㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("txoj"), "ㄊㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("txok"), "ㄊㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("txq"), "ㄊㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("txqf"), "ㄊㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("txqj"), "ㄊㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("txqk"), "ㄊㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("txm"), "ㄊㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("txmf"), "ㄊㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("txmj"), "ㄊㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("txmk"), "ㄊㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("txn"), "ㄊㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("txnf"), "ㄊㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("txnj"), "ㄊㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("txnk"), "ㄊㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("txl"), "ㄊㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("txlf"), "ㄊㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("txlj"), "ㄊㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("txlk"), "ㄊㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("na"), "ㄋㄚ");
  ASSERT_EQ(composer.cnvSequence("naf"), "ㄋㄚˊ");
  ASSERT_EQ(composer.cnvSequence("naj"), "ㄋㄚˇ");
  ASSERT_EQ(composer.cnvSequence("nak"), "ㄋㄚˋ");
  ASSERT_EQ(composer.cnvSequence("nad"), "ㄋㄚ˙");
  ASSERT_EQ(composer.cnvSequence("nrk"), "ㄋㄜˋ");
  ASSERT_EQ(composer.cnvSequence("nrd"), "ㄋㄜ˙");
  ASSERT_EQ(composer.cnvSequence("nif"), "ㄋㄞˊ");
  ASSERT_EQ(composer.cnvSequence("nij"), "ㄋㄞˇ");
  ASSERT_EQ(composer.cnvSequence("nik"), "ㄋㄞˋ");
  ASSERT_EQ(composer.cnvSequence("nqf"), "ㄋㄟˊ");
  ASSERT_EQ(composer.cnvSequence("nqj"), "ㄋㄟˇ");
  ASSERT_EQ(composer.cnvSequence("nqk"), "ㄋㄟˋ");
  ASSERT_EQ(composer.cnvSequence("nz"), "ㄋㄠ");
  ASSERT_EQ(composer.cnvSequence("nzf"), "ㄋㄠˊ");
  ASSERT_EQ(composer.cnvSequence("nzj"), "ㄋㄠˇ");
  ASSERT_EQ(composer.cnvSequence("nzk"), "ㄋㄠˋ");
  ASSERT_EQ(composer.cnvSequence("npf"), "ㄋㄡˊ");
  ASSERT_EQ(composer.cnvSequence("npj"), "ㄋㄡˇ");
  ASSERT_EQ(composer.cnvSequence("npk"), "ㄋㄡˋ");
  ASSERT_EQ(composer.cnvSequence("nm"), "ㄋㄢ");
  ASSERT_EQ(composer.cnvSequence("nmf"), "ㄋㄢˊ");
  ASSERT_EQ(composer.cnvSequence("nmj"), "ㄋㄢˇ");
  ASSERT_EQ(composer.cnvSequence("nmk"), "ㄋㄢˋ");
  ASSERT_EQ(composer.cnvSequence("nnj"), "ㄋㄣˇ");
  ASSERT_EQ(composer.cnvSequence("nnk"), "ㄋㄣˋ");
  ASSERT_EQ(composer.cnvSequence("nt"), "ㄋㄤ");
  ASSERT_EQ(composer.cnvSequence("ntf"), "ㄋㄤˊ");
  ASSERT_EQ(composer.cnvSequence("ntj"), "ㄋㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ntk"), "ㄋㄤˋ");
  ASSERT_EQ(composer.cnvSequence("ntd"), "ㄋㄤ˙");
  ASSERT_EQ(composer.cnvSequence("nlf"), "ㄋㄥˊ");
  ASSERT_EQ(composer.cnvSequence("nlj"), "ㄋㄥˇ");
  ASSERT_EQ(composer.cnvSequence("ne"), "ㄋㄧ");
  ASSERT_EQ(composer.cnvSequence("nef"), "ㄋㄧˊ");
  ASSERT_EQ(composer.cnvSequence("nej"), "ㄋㄧˇ");
  ASSERT_EQ(composer.cnvSequence("nek"), "ㄋㄧˋ");
  ASSERT_EQ(composer.cnvSequence("new"), "ㄋㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("newf"), "ㄋㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("newk"), "ㄋㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("nezj"), "ㄋㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("nezk"), "ㄋㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("nep"), "ㄋㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("nepf"), "ㄋㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("nepj"), "ㄋㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("nepk"), "ㄋㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("nem"), "ㄋㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("nemf"), "ㄋㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("nemj"), "ㄋㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("nemk"), "ㄋㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("nen"), "ㄋㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("nenf"), "ㄋㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("nenj"), "ㄋㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("nenk"), "ㄋㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("netf"), "ㄋㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("netj"), "ㄋㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("netk"), "ㄋㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("nelf"), "ㄋㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("nelj"), "ㄋㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("nelk"), "ㄋㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("nxf"), "ㄋㄨˊ");
  ASSERT_EQ(composer.cnvSequence("nxj"), "ㄋㄨˇ");
  ASSERT_EQ(composer.cnvSequence("nxk"), "ㄋㄨˋ");
  ASSERT_EQ(composer.cnvSequence("nxof"), "ㄋㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("nxoj"), "ㄋㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("nxok"), "ㄋㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("nxqf"), "ㄋㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("nxmf"), "ㄋㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("nxmj"), "ㄋㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("nxmk"), "ㄋㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("nxnf"), "ㄋㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("nxlf"), "ㄋㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("nxlj"), "ㄋㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("nxlk"), "ㄋㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("nuf"), "ㄋㄩˊ");
  ASSERT_EQ(composer.cnvSequence("nuj"), "ㄋㄩˇ");
  ASSERT_EQ(composer.cnvSequence("nuk"), "ㄋㄩˋ");
  ASSERT_EQ(composer.cnvSequence("nuwk"), "ㄋㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("la"), "ㄌㄚ");
  ASSERT_EQ(composer.cnvSequence("laf"), "ㄌㄚˊ");
  ASSERT_EQ(composer.cnvSequence("laj"), "ㄌㄚˇ");
  ASSERT_EQ(composer.cnvSequence("lak"), "ㄌㄚˋ");
  ASSERT_EQ(composer.cnvSequence("lad"), "ㄌㄚ˙");
  ASSERT_EQ(composer.cnvSequence("lo"), "ㄌㄛ");
  ASSERT_EQ(composer.cnvSequence("lod"), "ㄌㄛ˙");
  ASSERT_EQ(composer.cnvSequence("lr"), "ㄌㄜ");
  ASSERT_EQ(composer.cnvSequence("lrf"), "ㄌㄜˊ");
  ASSERT_EQ(composer.cnvSequence("lrk"), "ㄌㄜˋ");
  ASSERT_EQ(composer.cnvSequence("lrd"), "ㄌㄜ˙");
  ASSERT_EQ(composer.cnvSequence("lif"), "ㄌㄞˊ");
  ASSERT_EQ(composer.cnvSequence("lij"), "ㄌㄞˇ");
  ASSERT_EQ(composer.cnvSequence("lik"), "ㄌㄞˋ");
  ASSERT_EQ(composer.cnvSequence("lq"), "ㄌㄟ");
  ASSERT_EQ(composer.cnvSequence("lqf"), "ㄌㄟˊ");
  ASSERT_EQ(composer.cnvSequence("lqj"), "ㄌㄟˇ");
  ASSERT_EQ(composer.cnvSequence("lqk"), "ㄌㄟˋ");
  ASSERT_EQ(composer.cnvSequence("lqd"), "ㄌㄟ˙");
  ASSERT_EQ(composer.cnvSequence("lz"), "ㄌㄠ");
  ASSERT_EQ(composer.cnvSequence("lzf"), "ㄌㄠˊ");
  ASSERT_EQ(composer.cnvSequence("lzj"), "ㄌㄠˇ");
  ASSERT_EQ(composer.cnvSequence("lzk"), "ㄌㄠˋ");
  ASSERT_EQ(composer.cnvSequence("lp"), "ㄌㄡ");
  ASSERT_EQ(composer.cnvSequence("lpf"), "ㄌㄡˊ");
  ASSERT_EQ(composer.cnvSequence("lpj"), "ㄌㄡˇ");
  ASSERT_EQ(composer.cnvSequence("lpk"), "ㄌㄡˋ");
  ASSERT_EQ(composer.cnvSequence("lpd"), "ㄌㄡ˙");
  ASSERT_EQ(composer.cnvSequence("lmf"), "ㄌㄢˊ");
  ASSERT_EQ(composer.cnvSequence("lmj"), "ㄌㄢˇ");
  ASSERT_EQ(composer.cnvSequence("lmk"), "ㄌㄢˋ");
  ASSERT_EQ(composer.cnvSequence("lt"), "ㄌㄤ");
  ASSERT_EQ(composer.cnvSequence("ltf"), "ㄌㄤˊ");
  ASSERT_EQ(composer.cnvSequence("ltj"), "ㄌㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ltk"), "ㄌㄤˋ");
  ASSERT_EQ(composer.cnvSequence("ll"), "ㄌㄥ");
  ASSERT_EQ(composer.cnvSequence("llf"), "ㄌㄥˊ");
  ASSERT_EQ(composer.cnvSequence("llj"), "ㄌㄥˇ");
  ASSERT_EQ(composer.cnvSequence("llk"), "ㄌㄥˋ");
  ASSERT_EQ(composer.cnvSequence("le"), "ㄌㄧ");
  ASSERT_EQ(composer.cnvSequence("lef"), "ㄌㄧˊ");
  ASSERT_EQ(composer.cnvSequence("lej"), "ㄌㄧˇ");
  ASSERT_EQ(composer.cnvSequence("lek"), "ㄌㄧˋ");
  ASSERT_EQ(composer.cnvSequence("led"), "ㄌㄧ˙");
  ASSERT_EQ(composer.cnvSequence("leaj"), "ㄌㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("lew"), "ㄌㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("lewf"), "ㄌㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("lewj"), "ㄌㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("lewk"), "ㄌㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("lez"), "ㄌㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("lezf"), "ㄌㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("lezj"), "ㄌㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("lezk"), "ㄌㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("lep"), "ㄌㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("lepf"), "ㄌㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("lepj"), "ㄌㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("lepk"), "ㄌㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("lem"), "ㄌㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("lemf"), "ㄌㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("lemj"), "ㄌㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("lemk"), "ㄌㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("lenf"), "ㄌㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("lenj"), "ㄌㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("lenk"), "ㄌㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("letf"), "ㄌㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("letj"), "ㄌㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("letk"), "ㄌㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("lel"), "ㄌㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("lelf"), "ㄌㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("lelj"), "ㄌㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("lelk"), "ㄌㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("lx"), "ㄌㄨ");
  ASSERT_EQ(composer.cnvSequence("lxf"), "ㄌㄨˊ");
  ASSERT_EQ(composer.cnvSequence("lxj"), "ㄌㄨˇ");
  ASSERT_EQ(composer.cnvSequence("lxk"), "ㄌㄨˋ");
  ASSERT_EQ(composer.cnvSequence("lxo"), "ㄌㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("lxof"), "ㄌㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("lxoj"), "ㄌㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("lxok"), "ㄌㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("lxod"), "ㄌㄨㄛ˙");
  ASSERT_EQ(composer.cnvSequence("lxmf"), "ㄌㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("lxmj"), "ㄌㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("lxmk"), "ㄌㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("lxn"), "ㄌㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("lxnf"), "ㄌㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("lxnj"), "ㄌㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("lxnk"), "ㄌㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("lxl"), "ㄌㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("lxlf"), "ㄌㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("lxlj"), "ㄌㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("lxlk"), "ㄌㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("lu"), "ㄌㄩ");
  ASSERT_EQ(composer.cnvSequence("luf"), "ㄌㄩˊ");
  ASSERT_EQ(composer.cnvSequence("luj"), "ㄌㄩˇ");
  ASSERT_EQ(composer.cnvSequence("luk"), "ㄌㄩˋ");
  ASSERT_EQ(composer.cnvSequence("luw"), "ㄌㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("luwj"), "ㄌㄩㄝˇ");
  ASSERT_EQ(composer.cnvSequence("luwk"), "ㄌㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("lumf"), "ㄌㄩㄢˊ");
  ASSERT_EQ(composer.cnvSequence("lumj"), "ㄌㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("va"), "ㄍㄚ");
  ASSERT_EQ(composer.cnvSequence("vaf"), "ㄍㄚˊ");
  ASSERT_EQ(composer.cnvSequence("vaj"), "ㄍㄚˇ");
  ASSERT_EQ(composer.cnvSequence("vak"), "ㄍㄚˋ");
  ASSERT_EQ(composer.cnvSequence("vad"), "ㄍㄚ˙");
  ASSERT_EQ(composer.cnvSequence("vr"), "ㄍㄜ");
  ASSERT_EQ(composer.cnvSequence("vrf"), "ㄍㄜˊ");
  ASSERT_EQ(composer.cnvSequence("vrj"), "ㄍㄜˇ");
  ASSERT_EQ(composer.cnvSequence("vrk"), "ㄍㄜˋ");
  ASSERT_EQ(composer.cnvSequence("vrd"), "ㄍㄜ˙");
  ASSERT_EQ(composer.cnvSequence("vi"), "ㄍㄞ");
  ASSERT_EQ(composer.cnvSequence("vij"), "ㄍㄞˇ");
  ASSERT_EQ(composer.cnvSequence("vik"), "ㄍㄞˋ");
  ASSERT_EQ(composer.cnvSequence("vqj"), "ㄍㄟˇ");
  ASSERT_EQ(composer.cnvSequence("vz"), "ㄍㄠ");
  ASSERT_EQ(composer.cnvSequence("vzj"), "ㄍㄠˇ");
  ASSERT_EQ(composer.cnvSequence("vzk"), "ㄍㄠˋ");
  ASSERT_EQ(composer.cnvSequence("vp"), "ㄍㄡ");
  ASSERT_EQ(composer.cnvSequence("vpj"), "ㄍㄡˇ");
  ASSERT_EQ(composer.cnvSequence("vpk"), "ㄍㄡˋ");
  ASSERT_EQ(composer.cnvSequence("vm"), "ㄍㄢ");
  ASSERT_EQ(composer.cnvSequence("vmj"), "ㄍㄢˇ");
  ASSERT_EQ(composer.cnvSequence("vmk"), "ㄍㄢˋ");
  ASSERT_EQ(composer.cnvSequence("vn"), "ㄍㄣ");
  ASSERT_EQ(composer.cnvSequence("vnf"), "ㄍㄣˊ");
  ASSERT_EQ(composer.cnvSequence("vnj"), "ㄍㄣˇ");
  ASSERT_EQ(composer.cnvSequence("vnk"), "ㄍㄣˋ");
  ASSERT_EQ(composer.cnvSequence("vt"), "ㄍㄤ");
  ASSERT_EQ(composer.cnvSequence("vtj"), "ㄍㄤˇ");
  ASSERT_EQ(composer.cnvSequence("vtk"), "ㄍㄤˋ");
  ASSERT_EQ(composer.cnvSequence("vl"), "ㄍㄥ");
  ASSERT_EQ(composer.cnvSequence("vlj"), "ㄍㄥˇ");
  ASSERT_EQ(composer.cnvSequence("vlk"), "ㄍㄥˋ");
  ASSERT_EQ(composer.cnvSequence("vx"), "ㄍㄨ");
  ASSERT_EQ(composer.cnvSequence("vxf"), "ㄍㄨˊ");
  ASSERT_EQ(composer.cnvSequence("vxj"), "ㄍㄨˇ");
  ASSERT_EQ(composer.cnvSequence("vxk"), "ㄍㄨˋ");
  ASSERT_EQ(composer.cnvSequence("vxa"), "ㄍㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("vxaf"), "ㄍㄨㄚˊ");
  ASSERT_EQ(composer.cnvSequence("vxaj"), "ㄍㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("vxak"), "ㄍㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("vxo"), "ㄍㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("vxof"), "ㄍㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("vxoj"), "ㄍㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("vxok"), "ㄍㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("vxrf"), "ㄍㄨㄜˊ");
  ASSERT_EQ(composer.cnvSequence("vxi"), "ㄍㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("vxij"), "ㄍㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("vxik"), "ㄍㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("vxq"), "ㄍㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("vxqj"), "ㄍㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("vxqk"), "ㄍㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("vxm"), "ㄍㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("vxmj"), "ㄍㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("vxmk"), "ㄍㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("vxn"), "ㄍㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("vxnj"), "ㄍㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("vxnk"), "ㄍㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("vxt"), "ㄍㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("vxtj"), "ㄍㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("vxtk"), "ㄍㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("vxl"), "ㄍㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("vxlf"), "ㄍㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("vxlj"), "ㄍㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("vxlk"), "ㄍㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ka"), "ㄎㄚ");
  ASSERT_EQ(composer.cnvSequence("kaj"), "ㄎㄚˇ");
  ASSERT_EQ(composer.cnvSequence("kak"), "ㄎㄚˋ");
  ASSERT_EQ(composer.cnvSequence("kr"), "ㄎㄜ");
  ASSERT_EQ(composer.cnvSequence("krf"), "ㄎㄜˊ");
  ASSERT_EQ(composer.cnvSequence("krj"), "ㄎㄜˇ");
  ASSERT_EQ(composer.cnvSequence("krk"), "ㄎㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ki"), "ㄎㄞ");
  ASSERT_EQ(composer.cnvSequence("kij"), "ㄎㄞˇ");
  ASSERT_EQ(composer.cnvSequence("kik"), "ㄎㄞˋ");
  ASSERT_EQ(composer.cnvSequence("kz"), "ㄎㄠ");
  ASSERT_EQ(composer.cnvSequence("kzj"), "ㄎㄠˇ");
  ASSERT_EQ(composer.cnvSequence("kzk"), "ㄎㄠˋ");
  ASSERT_EQ(composer.cnvSequence("kp"), "ㄎㄡ");
  ASSERT_EQ(composer.cnvSequence("kpj"), "ㄎㄡˇ");
  ASSERT_EQ(composer.cnvSequence("kpk"), "ㄎㄡˋ");
  ASSERT_EQ(composer.cnvSequence("km"), "ㄎㄢ");
  ASSERT_EQ(composer.cnvSequence("kmj"), "ㄎㄢˇ");
  ASSERT_EQ(composer.cnvSequence("kmk"), "ㄎㄢˋ");
  ASSERT_EQ(composer.cnvSequence("kn"), "ㄎㄣ");
  ASSERT_EQ(composer.cnvSequence("knj"), "ㄎㄣˇ");
  ASSERT_EQ(composer.cnvSequence("knk"), "ㄎㄣˋ");
  ASSERT_EQ(composer.cnvSequence("kt"), "ㄎㄤ");
  ASSERT_EQ(composer.cnvSequence("ktf"), "ㄎㄤˊ");
  ASSERT_EQ(composer.cnvSequence("ktj"), "ㄎㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ktk"), "ㄎㄤˋ");
  ASSERT_EQ(composer.cnvSequence("kl"), "ㄎㄥ");
  ASSERT_EQ(composer.cnvSequence("klj"), "ㄎㄥˇ");
  ASSERT_EQ(composer.cnvSequence("kx"), "ㄎㄨ");
  ASSERT_EQ(composer.cnvSequence("kxf"), "ㄎㄨˊ");
  ASSERT_EQ(composer.cnvSequence("kxj"), "ㄎㄨˇ");
  ASSERT_EQ(composer.cnvSequence("kxk"), "ㄎㄨˋ");
  ASSERT_EQ(composer.cnvSequence("kxa"), "ㄎㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("kxaj"), "ㄎㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("kxak"), "ㄎㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("kxok"), "ㄎㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("kxi"), "ㄎㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("kxij"), "ㄎㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("kxik"), "ㄎㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("kxq"), "ㄎㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("kxqf"), "ㄎㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("kxqj"), "ㄎㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("kxqk"), "ㄎㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("kxm"), "ㄎㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("kxmj"), "ㄎㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("kxmk"), "ㄎㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("kxn"), "ㄎㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("kxnj"), "ㄎㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("kxnk"), "ㄎㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("kxt"), "ㄎㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("kxtf"), "ㄎㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("kxtj"), "ㄎㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("kxtk"), "ㄎㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("kxl"), "ㄎㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("kxlj"), "ㄎㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("kxlk"), "ㄎㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ha"), "ㄏㄚ");
  ASSERT_EQ(composer.cnvSequence("haf"), "ㄏㄚˊ");
  ASSERT_EQ(composer.cnvSequence("haj"), "ㄏㄚˇ");
  ASSERT_EQ(composer.cnvSequence("hr"), "ㄏㄜ");
  ASSERT_EQ(composer.cnvSequence("hrf"), "ㄏㄜˊ");
  ASSERT_EQ(composer.cnvSequence("hrj"), "ㄏㄜˇ");
  ASSERT_EQ(composer.cnvSequence("hrk"), "ㄏㄜˋ");
  ASSERT_EQ(composer.cnvSequence("hi"), "ㄏㄞ");
  ASSERT_EQ(composer.cnvSequence("hif"), "ㄏㄞˊ");
  ASSERT_EQ(composer.cnvSequence("hij"), "ㄏㄞˇ");
  ASSERT_EQ(composer.cnvSequence("hik"), "ㄏㄞˋ");
  ASSERT_EQ(composer.cnvSequence("hq"), "ㄏㄟ");
  ASSERT_EQ(composer.cnvSequence("hqj"), "ㄏㄟˇ");
  ASSERT_EQ(composer.cnvSequence("hz"), "ㄏㄠ");
  ASSERT_EQ(composer.cnvSequence("hzf"), "ㄏㄠˊ");
  ASSERT_EQ(composer.cnvSequence("hzj"), "ㄏㄠˇ");
  ASSERT_EQ(composer.cnvSequence("hzk"), "ㄏㄠˋ");
  ASSERT_EQ(composer.cnvSequence("hp"), "ㄏㄡ");
  ASSERT_EQ(composer.cnvSequence("hpf"), "ㄏㄡˊ");
  ASSERT_EQ(composer.cnvSequence("hpj"), "ㄏㄡˇ");
  ASSERT_EQ(composer.cnvSequence("hpk"), "ㄏㄡˋ");
  ASSERT_EQ(composer.cnvSequence("hm"), "ㄏㄢ");
  ASSERT_EQ(composer.cnvSequence("hmf"), "ㄏㄢˊ");
  ASSERT_EQ(composer.cnvSequence("hmj"), "ㄏㄢˇ");
  ASSERT_EQ(composer.cnvSequence("hmk"), "ㄏㄢˋ");
  ASSERT_EQ(composer.cnvSequence("hn"), "ㄏㄣ");
  ASSERT_EQ(composer.cnvSequence("hnf"), "ㄏㄣˊ");
  ASSERT_EQ(composer.cnvSequence("hnj"), "ㄏㄣˇ");
  ASSERT_EQ(composer.cnvSequence("hnk"), "ㄏㄣˋ");
  ASSERT_EQ(composer.cnvSequence("ht"), "ㄏㄤ");
  ASSERT_EQ(composer.cnvSequence("htf"), "ㄏㄤˊ");
  ASSERT_EQ(composer.cnvSequence("htj"), "ㄏㄤˇ");
  ASSERT_EQ(composer.cnvSequence("htk"), "ㄏㄤˋ");
  ASSERT_EQ(composer.cnvSequence("hl"), "ㄏㄥ");
  ASSERT_EQ(composer.cnvSequence("hlf"), "ㄏㄥˊ");
  ASSERT_EQ(composer.cnvSequence("hlk"), "ㄏㄥˋ");
  ASSERT_EQ(composer.cnvSequence("hx"), "ㄏㄨ");
  ASSERT_EQ(composer.cnvSequence("hxf"), "ㄏㄨˊ");
  ASSERT_EQ(composer.cnvSequence("hxj"), "ㄏㄨˇ");
  ASSERT_EQ(composer.cnvSequence("hxk"), "ㄏㄨˋ");
  ASSERT_EQ(composer.cnvSequence("hxa"), "ㄏㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("hxaf"), "ㄏㄨㄚˊ");
  ASSERT_EQ(composer.cnvSequence("hxaj"), "ㄏㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("hxak"), "ㄏㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("hxo"), "ㄏㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("hxof"), "ㄏㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("hxoj"), "ㄏㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("hxok"), "ㄏㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("hxod"), "ㄏㄨㄛ˙");
  ASSERT_EQ(composer.cnvSequence("hxif"), "ㄏㄨㄞˊ");
  ASSERT_EQ(composer.cnvSequence("hxik"), "ㄏㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("hxq"), "ㄏㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("hxqf"), "ㄏㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("hxqj"), "ㄏㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("hxqk"), "ㄏㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("hxm"), "ㄏㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("hxmf"), "ㄏㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("hxmj"), "ㄏㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("hxmk"), "ㄏㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("hxn"), "ㄏㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("hxnf"), "ㄏㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("hxnj"), "ㄏㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("hxnk"), "ㄏㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("hxt"), "ㄏㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("hxtf"), "ㄏㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("hxtj"), "ㄏㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("hxtk"), "ㄏㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("hxtd"), "ㄏㄨㄤ˙");
  ASSERT_EQ(composer.cnvSequence("hxl"), "ㄏㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("hxlf"), "ㄏㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("hxlj"), "ㄏㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("hxlk"), "ㄏㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ge"), "ㄐㄧ");
  ASSERT_EQ(composer.cnvSequence("gef"), "ㄐㄧˊ");
  ASSERT_EQ(composer.cnvSequence("gej"), "ㄐㄧˇ");
  ASSERT_EQ(composer.cnvSequence("gek"), "ㄐㄧˋ");
  ASSERT_EQ(composer.cnvSequence("gea"), "ㄐㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("geaf"), "ㄐㄧㄚˊ");
  ASSERT_EQ(composer.cnvSequence("geaj"), "ㄐㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("geak"), "ㄐㄧㄚˋ");
  ASSERT_EQ(composer.cnvSequence("gew"), "ㄐㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("gewf"), "ㄐㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("gewj"), "ㄐㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("gewk"), "ㄐㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("gewd"), "ㄐㄧㄝ˙");
  ASSERT_EQ(composer.cnvSequence("gez"), "ㄐㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("gezf"), "ㄐㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("gezj"), "ㄐㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("gezk"), "ㄐㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("gep"), "ㄐㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("gepj"), "ㄐㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("gepk"), "ㄐㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("gem"), "ㄐㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("gemj"), "ㄐㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("gemk"), "ㄐㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("gen"), "ㄐㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("genj"), "ㄐㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("genk"), "ㄐㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("get"), "ㄐㄧㄤ");
  ASSERT_EQ(composer.cnvSequence("getf"), "ㄐㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("getj"), "ㄐㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("getk"), "ㄐㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("gel"), "ㄐㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("gelj"), "ㄐㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("gelk"), "ㄐㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("gu"), "ㄐㄩ");
  ASSERT_EQ(composer.cnvSequence("guf"), "ㄐㄩˊ");
  ASSERT_EQ(composer.cnvSequence("guj"), "ㄐㄩˇ");
  ASSERT_EQ(composer.cnvSequence("guk"), "ㄐㄩˋ");
  ASSERT_EQ(composer.cnvSequence("guw"), "ㄐㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("guwf"), "ㄐㄩㄝˊ");
  ASSERT_EQ(composer.cnvSequence("guwj"), "ㄐㄩㄝˇ");
  ASSERT_EQ(composer.cnvSequence("guwk"), "ㄐㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("gum"), "ㄐㄩㄢ");
  ASSERT_EQ(composer.cnvSequence("gumj"), "ㄐㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("gumk"), "ㄐㄩㄢˋ");
  ASSERT_EQ(composer.cnvSequence("gun"), "ㄐㄩㄣ");
  ASSERT_EQ(composer.cnvSequence("gunf"), "ㄐㄩㄣˊ");
  ASSERT_EQ(composer.cnvSequence("gunj"), "ㄐㄩㄣˇ");
  ASSERT_EQ(composer.cnvSequence("gunk"), "ㄐㄩㄣˋ");
  ASSERT_EQ(composer.cnvSequence("gul"), "ㄐㄩㄥ");
  ASSERT_EQ(composer.cnvSequence("gulj"), "ㄐㄩㄥˇ");
  ASSERT_EQ(composer.cnvSequence("gulk"), "ㄐㄩㄥˋ");
  // ASSERT_EQ(composer.cnvSequence("vd"), "ㄑ˙");
  ASSERT_EQ(composer.cnvSequence("ve"), "ㄑㄧ");
  ASSERT_EQ(composer.cnvSequence("vef"), "ㄑㄧˊ");
  ASSERT_EQ(composer.cnvSequence("vej"), "ㄑㄧˇ");
  ASSERT_EQ(composer.cnvSequence("vek"), "ㄑㄧˋ");
  ASSERT_EQ(composer.cnvSequence("vea"), "ㄑㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("veaf"), "ㄑㄧㄚˊ");
  ASSERT_EQ(composer.cnvSequence("veaj"), "ㄑㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("veak"), "ㄑㄧㄚˋ");
  ASSERT_EQ(composer.cnvSequence("vew"), "ㄑㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("vewf"), "ㄑㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("vewj"), "ㄑㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("vewk"), "ㄑㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("vez"), "ㄑㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("vezf"), "ㄑㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("vezj"), "ㄑㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("vezk"), "ㄑㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("vep"), "ㄑㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("vepf"), "ㄑㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("vepj"), "ㄑㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("vepk"), "ㄑㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("vem"), "ㄑㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("vemf"), "ㄑㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("vemj"), "ㄑㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("vemk"), "ㄑㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("ven"), "ㄑㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("venf"), "ㄑㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("venj"), "ㄑㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("venk"), "ㄑㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("vet"), "ㄑㄧㄤ");
  ASSERT_EQ(composer.cnvSequence("vetf"), "ㄑㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("vetj"), "ㄑㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("vetk"), "ㄑㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("vel"), "ㄑㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("velf"), "ㄑㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("velj"), "ㄑㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("velk"), "ㄑㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("vu"), "ㄑㄩ");
  ASSERT_EQ(composer.cnvSequence("vuf"), "ㄑㄩˊ");
  ASSERT_EQ(composer.cnvSequence("vuj"), "ㄑㄩˇ");
  ASSERT_EQ(composer.cnvSequence("vuk"), "ㄑㄩˋ");
  ASSERT_EQ(composer.cnvSequence("vuw"), "ㄑㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("vuwf"), "ㄑㄩㄝˊ");
  ASSERT_EQ(composer.cnvSequence("vuwk"), "ㄑㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("vum"), "ㄑㄩㄢ");
  ASSERT_EQ(composer.cnvSequence("vumf"), "ㄑㄩㄢˊ");
  ASSERT_EQ(composer.cnvSequence("vumj"), "ㄑㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("vumk"), "ㄑㄩㄢˋ");
  ASSERT_EQ(composer.cnvSequence("vun"), "ㄑㄩㄣ");
  ASSERT_EQ(composer.cnvSequence("vunf"), "ㄑㄩㄣˊ");
  ASSERT_EQ(composer.cnvSequence("vunj"), "ㄑㄩㄣˇ");
  ASSERT_EQ(composer.cnvSequence("vunk"), "ㄑㄩㄣˋ");
  ASSERT_EQ(composer.cnvSequence("vul"), "ㄑㄩㄥ");
  ASSERT_EQ(composer.cnvSequence("vulf"), "ㄑㄩㄥˊ");
  ASSERT_EQ(composer.cnvSequence("vulj"), "ㄑㄩㄥˇ");
  ASSERT_EQ(composer.cnvSequence("vulk"), "ㄑㄩㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ce"), "ㄒㄧ");
  ASSERT_EQ(composer.cnvSequence("cef"), "ㄒㄧˊ");
  ASSERT_EQ(composer.cnvSequence("cej"), "ㄒㄧˇ");
  ASSERT_EQ(composer.cnvSequence("cek"), "ㄒㄧˋ");
  ASSERT_EQ(composer.cnvSequence("cea"), "ㄒㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("ceaf"), "ㄒㄧㄚˊ");
  ASSERT_EQ(composer.cnvSequence("ceaj"), "ㄒㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("ceak"), "ㄒㄧㄚˋ");
  ASSERT_EQ(composer.cnvSequence("cew"), "ㄒㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("cewf"), "ㄒㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("cewj"), "ㄒㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("cewk"), "ㄒㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("cez"), "ㄒㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("cezf"), "ㄒㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("cezj"), "ㄒㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("cezk"), "ㄒㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("cep"), "ㄒㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("cepf"), "ㄒㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("cepj"), "ㄒㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("cepk"), "ㄒㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("cem"), "ㄒㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("cemf"), "ㄒㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("cemj"), "ㄒㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("cemk"), "ㄒㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("cen"), "ㄒㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("cenf"), "ㄒㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("cenj"), "ㄒㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("cenk"), "ㄒㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("cet"), "ㄒㄧㄤ");
  ASSERT_EQ(composer.cnvSequence("cetf"), "ㄒㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("cetj"), "ㄒㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("cetk"), "ㄒㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("cel"), "ㄒㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("celf"), "ㄒㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("celj"), "ㄒㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("celk"), "ㄒㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("cu"), "ㄒㄩ");
  ASSERT_EQ(composer.cnvSequence("cuf"), "ㄒㄩˊ");
  ASSERT_EQ(composer.cnvSequence("cuj"), "ㄒㄩˇ");
  ASSERT_EQ(composer.cnvSequence("cuk"), "ㄒㄩˋ");
  ASSERT_EQ(composer.cnvSequence("cuw"), "ㄒㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("cuwf"), "ㄒㄩㄝˊ");
  ASSERT_EQ(composer.cnvSequence("cuwj"), "ㄒㄩㄝˇ");
  ASSERT_EQ(composer.cnvSequence("cuwk"), "ㄒㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("cum"), "ㄒㄩㄢ");
  ASSERT_EQ(composer.cnvSequence("cumf"), "ㄒㄩㄢˊ");
  ASSERT_EQ(composer.cnvSequence("cumj"), "ㄒㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("cumk"), "ㄒㄩㄢˋ");
  ASSERT_EQ(composer.cnvSequence("cun"), "ㄒㄩㄣ");
  ASSERT_EQ(composer.cnvSequence("cunf"), "ㄒㄩㄣˊ");
  ASSERT_EQ(composer.cnvSequence("cunk"), "ㄒㄩㄣˋ");
  ASSERT_EQ(composer.cnvSequence("cul"), "ㄒㄩㄥ");
  ASSERT_EQ(composer.cnvSequence("culf"), "ㄒㄩㄥˊ");
  ASSERT_EQ(composer.cnvSequence("culj"), "ㄒㄩㄥˇ");
  ASSERT_EQ(composer.cnvSequence("culk"), "ㄒㄩㄥˋ");
  ASSERT_EQ(composer.cnvSequence("g"), "ㄓ");
  ASSERT_EQ(composer.cnvSequence("gf"), "ㄓˊ");
  ASSERT_EQ(composer.cnvSequence("gj"), "ㄓˇ");
  ASSERT_EQ(composer.cnvSequence("gk"), "ㄓˋ");
  ASSERT_EQ(composer.cnvSequence("ga"), "ㄓㄚ");
  ASSERT_EQ(composer.cnvSequence("gaf"), "ㄓㄚˊ");
  ASSERT_EQ(composer.cnvSequence("gaj"), "ㄓㄚˇ");
  ASSERT_EQ(composer.cnvSequence("gak"), "ㄓㄚˋ");
  ASSERT_EQ(composer.cnvSequence("gr"), "ㄓㄜ");
  ASSERT_EQ(composer.cnvSequence("grf"), "ㄓㄜˊ");
  ASSERT_EQ(composer.cnvSequence("grj"), "ㄓㄜˇ");
  ASSERT_EQ(composer.cnvSequence("grk"), "ㄓㄜˋ");
  ASSERT_EQ(composer.cnvSequence("grd"), "ㄓㄜ˙");
  ASSERT_EQ(composer.cnvSequence("gi"), "ㄓㄞ");
  ASSERT_EQ(composer.cnvSequence("gif"), "ㄓㄞˊ");
  ASSERT_EQ(composer.cnvSequence("gij"), "ㄓㄞˇ");
  ASSERT_EQ(composer.cnvSequence("gik"), "ㄓㄞˋ");
  ASSERT_EQ(composer.cnvSequence("gqk"), "ㄓㄟˋ");
  ASSERT_EQ(composer.cnvSequence("gz"), "ㄓㄠ");
  ASSERT_EQ(composer.cnvSequence("gzf"), "ㄓㄠˊ");
  ASSERT_EQ(composer.cnvSequence("gzj"), "ㄓㄠˇ");
  ASSERT_EQ(composer.cnvSequence("gzk"), "ㄓㄠˋ");
  ASSERT_EQ(composer.cnvSequence("gp"), "ㄓㄡ");
  ASSERT_EQ(composer.cnvSequence("gpf"), "ㄓㄡˊ");
  ASSERT_EQ(composer.cnvSequence("gpj"), "ㄓㄡˇ");
  ASSERT_EQ(composer.cnvSequence("gpk"), "ㄓㄡˋ");
  ASSERT_EQ(composer.cnvSequence("gm"), "ㄓㄢ");
  ASSERT_EQ(composer.cnvSequence("gmj"), "ㄓㄢˇ");
  ASSERT_EQ(composer.cnvSequence("gmk"), "ㄓㄢˋ");
  ASSERT_EQ(composer.cnvSequence("gn"), "ㄓㄣ");
  ASSERT_EQ(composer.cnvSequence("gnf"), "ㄓㄣˊ");
  ASSERT_EQ(composer.cnvSequence("gnj"), "ㄓㄣˇ");
  ASSERT_EQ(composer.cnvSequence("gnk"), "ㄓㄣˋ");
  ASSERT_EQ(composer.cnvSequence("gt"), "ㄓㄤ");
  ASSERT_EQ(composer.cnvSequence("gtj"), "ㄓㄤˇ");
  ASSERT_EQ(composer.cnvSequence("gtk"), "ㄓㄤˋ");
  ASSERT_EQ(composer.cnvSequence("gl"), "ㄓㄥ");
  ASSERT_EQ(composer.cnvSequence("glj"), "ㄓㄥˇ");
  ASSERT_EQ(composer.cnvSequence("glk"), "ㄓㄥˋ");
  ASSERT_EQ(composer.cnvSequence("gx"), "ㄓㄨ");
  ASSERT_EQ(composer.cnvSequence("gxf"), "ㄓㄨˊ");
  ASSERT_EQ(composer.cnvSequence("gxj"), "ㄓㄨˇ");
  ASSERT_EQ(composer.cnvSequence("gxk"), "ㄓㄨˋ");
  ASSERT_EQ(composer.cnvSequence("gxa"), "ㄓㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("gxaj"), "ㄓㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("gxo"), "ㄓㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("gxof"), "ㄓㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("gxok"), "ㄓㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("gxi"), "ㄓㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("gxij"), "ㄓㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("gxik"), "ㄓㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("gxq"), "ㄓㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("gxqj"), "ㄓㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("gxqk"), "ㄓㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("gxm"), "ㄓㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("gxmj"), "ㄓㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("gxmk"), "ㄓㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("gxn"), "ㄓㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("gxnj"), "ㄓㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("gxnk"), "ㄓㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("gxt"), "ㄓㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("gxtj"), "ㄓㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("gxtk"), "ㄓㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("gxl"), "ㄓㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("gxlj"), "ㄓㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("gxlk"), "ㄓㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("y"), "ㄔ");
  ASSERT_EQ(composer.cnvSequence("yf"), "ㄔˊ");
  ASSERT_EQ(composer.cnvSequence("yj"), "ㄔˇ");
  ASSERT_EQ(composer.cnvSequence("yk"), "ㄔˋ");
  ASSERT_EQ(composer.cnvSequence("ya"), "ㄔㄚ");
  ASSERT_EQ(composer.cnvSequence("yaf"), "ㄔㄚˊ");
  ASSERT_EQ(composer.cnvSequence("yaj"), "ㄔㄚˇ");
  ASSERT_EQ(composer.cnvSequence("yak"), "ㄔㄚˋ");
  ASSERT_EQ(composer.cnvSequence("yr"), "ㄔㄜ");
  ASSERT_EQ(composer.cnvSequence("yrj"), "ㄔㄜˇ");
  ASSERT_EQ(composer.cnvSequence("yrk"), "ㄔㄜˋ");
  ASSERT_EQ(composer.cnvSequence("yi"), "ㄔㄞ");
  ASSERT_EQ(composer.cnvSequence("yif"), "ㄔㄞˊ");
  ASSERT_EQ(composer.cnvSequence("yij"), "ㄔㄞˇ");
  ASSERT_EQ(composer.cnvSequence("yik"), "ㄔㄞˋ");
  ASSERT_EQ(composer.cnvSequence("yz"), "ㄔㄠ");
  ASSERT_EQ(composer.cnvSequence("yzf"), "ㄔㄠˊ");
  ASSERT_EQ(composer.cnvSequence("yzj"), "ㄔㄠˇ");
  ASSERT_EQ(composer.cnvSequence("yzk"), "ㄔㄠˋ");
  ASSERT_EQ(composer.cnvSequence("yp"), "ㄔㄡ");
  ASSERT_EQ(composer.cnvSequence("ypf"), "ㄔㄡˊ");
  ASSERT_EQ(composer.cnvSequence("ypj"), "ㄔㄡˇ");
  ASSERT_EQ(composer.cnvSequence("ypk"), "ㄔㄡˋ");
  ASSERT_EQ(composer.cnvSequence("ym"), "ㄔㄢ");
  ASSERT_EQ(composer.cnvSequence("ymf"), "ㄔㄢˊ");
  ASSERT_EQ(composer.cnvSequence("ymj"), "ㄔㄢˇ");
  ASSERT_EQ(composer.cnvSequence("ymk"), "ㄔㄢˋ");
  ASSERT_EQ(composer.cnvSequence("yn"), "ㄔㄣ");
  ASSERT_EQ(composer.cnvSequence("ynf"), "ㄔㄣˊ");
  ASSERT_EQ(composer.cnvSequence("ynj"), "ㄔㄣˇ");
  ASSERT_EQ(composer.cnvSequence("ynk"), "ㄔㄣˋ");
  ASSERT_EQ(composer.cnvSequence("ynd"), "ㄔㄣ˙");
  ASSERT_EQ(composer.cnvSequence("yt"), "ㄔㄤ");
  ASSERT_EQ(composer.cnvSequence("ytf"), "ㄔㄤˊ");
  ASSERT_EQ(composer.cnvSequence("ytj"), "ㄔㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ytk"), "ㄔㄤˋ");
  ASSERT_EQ(composer.cnvSequence("yl"), "ㄔㄥ");
  ASSERT_EQ(composer.cnvSequence("ylf"), "ㄔㄥˊ");
  ASSERT_EQ(composer.cnvSequence("ylj"), "ㄔㄥˇ");
  ASSERT_EQ(composer.cnvSequence("ylk"), "ㄔㄥˋ");
  ASSERT_EQ(composer.cnvSequence("yx"), "ㄔㄨ");
  ASSERT_EQ(composer.cnvSequence("yxf"), "ㄔㄨˊ");
  ASSERT_EQ(composer.cnvSequence("yxj"), "ㄔㄨˇ");
  ASSERT_EQ(composer.cnvSequence("yxk"), "ㄔㄨˋ");
  ASSERT_EQ(composer.cnvSequence("yxa"), "ㄔㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("yxaj"), "ㄔㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("yxak"), "ㄔㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("yxo"), "ㄔㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("yxok"), "ㄔㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("yxi"), "ㄔㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("yxif"), "ㄔㄨㄞˊ");
  ASSERT_EQ(composer.cnvSequence("yxij"), "ㄔㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("yxik"), "ㄔㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("yxq"), "ㄔㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("yxqf"), "ㄔㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("yxqj"), "ㄔㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("yxqk"), "ㄔㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("yxm"), "ㄔㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("yxmf"), "ㄔㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("yxmj"), "ㄔㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("yxmk"), "ㄔㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("yxn"), "ㄔㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("yxnf"), "ㄔㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("yxnj"), "ㄔㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("yxt"), "ㄔㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("yxtf"), "ㄔㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("yxtj"), "ㄔㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("yxtk"), "ㄔㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("yxl"), "ㄔㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("yxlf"), "ㄔㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("yxlj"), "ㄔㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("yxlk"), "ㄔㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("c"), "ㄕ");
  ASSERT_EQ(composer.cnvSequence("cf"), "ㄕˊ");
  ASSERT_EQ(composer.cnvSequence("cj"), "ㄕˇ");
  ASSERT_EQ(composer.cnvSequence("ck"), "ㄕˋ");
  ASSERT_EQ(composer.cnvSequence("cd"), "ㄕ˙");
  ASSERT_EQ(composer.cnvSequence("ca"), "ㄕㄚ");
  ASSERT_EQ(composer.cnvSequence("caf"), "ㄕㄚˊ");
  ASSERT_EQ(composer.cnvSequence("caj"), "ㄕㄚˇ");
  ASSERT_EQ(composer.cnvSequence("cak"), "ㄕㄚˋ");
  ASSERT_EQ(composer.cnvSequence("cad"), "ㄕㄚ˙");
  ASSERT_EQ(composer.cnvSequence("cr"), "ㄕㄜ");
  ASSERT_EQ(composer.cnvSequence("crf"), "ㄕㄜˊ");
  ASSERT_EQ(composer.cnvSequence("crj"), "ㄕㄜˇ");
  ASSERT_EQ(composer.cnvSequence("crk"), "ㄕㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ci"), "ㄕㄞ");
  ASSERT_EQ(composer.cnvSequence("cij"), "ㄕㄞˇ");
  ASSERT_EQ(composer.cnvSequence("cik"), "ㄕㄞˋ");
  ASSERT_EQ(composer.cnvSequence("cqf"), "ㄕㄟˊ");
  ASSERT_EQ(composer.cnvSequence("cz"), "ㄕㄠ");
  ASSERT_EQ(composer.cnvSequence("czf"), "ㄕㄠˊ");
  ASSERT_EQ(composer.cnvSequence("czj"), "ㄕㄠˇ");
  ASSERT_EQ(composer.cnvSequence("czk"), "ㄕㄠˋ");
  ASSERT_EQ(composer.cnvSequence("cp"), "ㄕㄡ");
  ASSERT_EQ(composer.cnvSequence("cpf"), "ㄕㄡˊ");
  ASSERT_EQ(composer.cnvSequence("cpj"), "ㄕㄡˇ");
  ASSERT_EQ(composer.cnvSequence("cpk"), "ㄕㄡˋ");
  ASSERT_EQ(composer.cnvSequence("cm"), "ㄕㄢ");
  ASSERT_EQ(composer.cnvSequence("cmf"), "ㄕㄢˊ");
  ASSERT_EQ(composer.cnvSequence("cmj"), "ㄕㄢˇ");
  ASSERT_EQ(composer.cnvSequence("cmk"), "ㄕㄢˋ");
  ASSERT_EQ(composer.cnvSequence("cn"), "ㄕㄣ");
  ASSERT_EQ(composer.cnvSequence("cnf"), "ㄕㄣˊ");
  ASSERT_EQ(composer.cnvSequence("cnj"), "ㄕㄣˇ");
  ASSERT_EQ(composer.cnvSequence("cnk"), "ㄕㄣˋ");
  ASSERT_EQ(composer.cnvSequence("ct"), "ㄕㄤ");
  ASSERT_EQ(composer.cnvSequence("ctj"), "ㄕㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ctk"), "ㄕㄤˋ");
  ASSERT_EQ(composer.cnvSequence("ctd"), "ㄕㄤ˙");
  ASSERT_EQ(composer.cnvSequence("cl"), "ㄕㄥ");
  ASSERT_EQ(composer.cnvSequence("clf"), "ㄕㄥˊ");
  ASSERT_EQ(composer.cnvSequence("clj"), "ㄕㄥˇ");
  ASSERT_EQ(composer.cnvSequence("clk"), "ㄕㄥˋ");
  ASSERT_EQ(composer.cnvSequence("cx"), "ㄕㄨ");
  ASSERT_EQ(composer.cnvSequence("cxf"), "ㄕㄨˊ");
  ASSERT_EQ(composer.cnvSequence("cxj"), "ㄕㄨˇ");
  ASSERT_EQ(composer.cnvSequence("cxk"), "ㄕㄨˋ");
  ASSERT_EQ(composer.cnvSequence("cxa"), "ㄕㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("cxaj"), "ㄕㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("cxak"), "ㄕㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("cxo"), "ㄕㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("cxok"), "ㄕㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("cxi"), "ㄕㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("cxij"), "ㄕㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("cxik"), "ㄕㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("cxq"), "ㄕㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("cxqf"), "ㄕㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("cxqj"), "ㄕㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("cxqk"), "ㄕㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("cxm"), "ㄕㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("cxmk"), "ㄕㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("cxnj"), "ㄕㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("cxnk"), "ㄕㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("cxt"), "ㄕㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("cxtf"), "ㄕㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("cxtj"), "ㄕㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("cxtk"), "ㄕㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("jk"), "ㄖˋ");
  ASSERT_EQ(composer.cnvSequence("jrj"), "ㄖㄜˇ");
  ASSERT_EQ(composer.cnvSequence("jrk"), "ㄖㄜˋ");
  ASSERT_EQ(composer.cnvSequence("jzf"), "ㄖㄠˊ");
  ASSERT_EQ(composer.cnvSequence("jzj"), "ㄖㄠˇ");
  ASSERT_EQ(composer.cnvSequence("jzk"), "ㄖㄠˋ");
  ASSERT_EQ(composer.cnvSequence("jpf"), "ㄖㄡˊ");
  ASSERT_EQ(composer.cnvSequence("jpj"), "ㄖㄡˇ");
  ASSERT_EQ(composer.cnvSequence("jpk"), "ㄖㄡˋ");
  ASSERT_EQ(composer.cnvSequence("jmf"), "ㄖㄢˊ");
  ASSERT_EQ(composer.cnvSequence("jmj"), "ㄖㄢˇ");
  ASSERT_EQ(composer.cnvSequence("jmk"), "ㄖㄢˋ");
  ASSERT_EQ(composer.cnvSequence("jnf"), "ㄖㄣˊ");
  ASSERT_EQ(composer.cnvSequence("jnj"), "ㄖㄣˇ");
  ASSERT_EQ(composer.cnvSequence("jnk"), "ㄖㄣˋ");
  ASSERT_EQ(composer.cnvSequence("jt"), "ㄖㄤ");
  ASSERT_EQ(composer.cnvSequence("jtf"), "ㄖㄤˊ");
  ASSERT_EQ(composer.cnvSequence("jtj"), "ㄖㄤˇ");
  ASSERT_EQ(composer.cnvSequence("jtk"), "ㄖㄤˋ");
  ASSERT_EQ(composer.cnvSequence("jl"), "ㄖㄥ");
  ASSERT_EQ(composer.cnvSequence("jlf"), "ㄖㄥˊ");
  ASSERT_EQ(composer.cnvSequence("jlj"), "ㄖㄥˇ");
  ASSERT_EQ(composer.cnvSequence("jlk"), "ㄖㄥˋ");
  ASSERT_EQ(composer.cnvSequence("jxf"), "ㄖㄨˊ");
  ASSERT_EQ(composer.cnvSequence("jxj"), "ㄖㄨˇ");
  ASSERT_EQ(composer.cnvSequence("jxk"), "ㄖㄨˋ");
  ASSERT_EQ(composer.cnvSequence("jxof"), "ㄖㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("jxok"), "ㄖㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("jxqf"), "ㄖㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("jxqj"), "ㄖㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("jxqk"), "ㄖㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("jxmf"), "ㄖㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("jxmj"), "ㄖㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("jxmk"), "ㄖㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("jxnf"), "ㄖㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("jxnj"), "ㄖㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("jxnk"), "ㄖㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("jxlf"), "ㄖㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("jxlj"), "ㄖㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("jxlk"), "ㄖㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("q"), "ㄗ");
  ASSERT_EQ(composer.cnvSequence("qf"), "ㄗˊ");
  ASSERT_EQ(composer.cnvSequence("qj"), "ㄗˇ");
  ASSERT_EQ(composer.cnvSequence("qk"), "ㄗˋ");
  ASSERT_EQ(composer.cnvSequence("qd"), "ㄗ˙");
  ASSERT_EQ(composer.cnvSequence("qa"), "ㄗㄚ");
  ASSERT_EQ(composer.cnvSequence("qaf"), "ㄗㄚˊ");
  ASSERT_EQ(composer.cnvSequence("qaj"), "ㄗㄚˇ");
  ASSERT_EQ(composer.cnvSequence("qrf"), "ㄗㄜˊ");
  ASSERT_EQ(composer.cnvSequence("qrj"), "ㄗㄜˇ");
  ASSERT_EQ(composer.cnvSequence("qrk"), "ㄗㄜˋ");
  ASSERT_EQ(composer.cnvSequence("qi"), "ㄗㄞ");
  ASSERT_EQ(composer.cnvSequence("qij"), "ㄗㄞˇ");
  ASSERT_EQ(composer.cnvSequence("qik"), "ㄗㄞˋ");
  ASSERT_EQ(composer.cnvSequence("qqf"), "ㄗㄟˊ");
  ASSERT_EQ(composer.cnvSequence("qz"), "ㄗㄠ");
  ASSERT_EQ(composer.cnvSequence("qzf"), "ㄗㄠˊ");
  ASSERT_EQ(composer.cnvSequence("qzj"), "ㄗㄠˇ");
  ASSERT_EQ(composer.cnvSequence("qzk"), "ㄗㄠˋ");
  ASSERT_EQ(composer.cnvSequence("qp"), "ㄗㄡ");
  ASSERT_EQ(composer.cnvSequence("qpj"), "ㄗㄡˇ");
  ASSERT_EQ(composer.cnvSequence("qpk"), "ㄗㄡˋ");
  ASSERT_EQ(composer.cnvSequence("qm"), "ㄗㄢ");
  ASSERT_EQ(composer.cnvSequence("qmf"), "ㄗㄢˊ");
  ASSERT_EQ(composer.cnvSequence("qmj"), "ㄗㄢˇ");
  ASSERT_EQ(composer.cnvSequence("qmk"), "ㄗㄢˋ");
  ASSERT_EQ(composer.cnvSequence("qn"), "ㄗㄣ");
  ASSERT_EQ(composer.cnvSequence("qnj"), "ㄗㄣˇ");
  ASSERT_EQ(composer.cnvSequence("qnk"), "ㄗㄣˋ");
  ASSERT_EQ(composer.cnvSequence("qt"), "ㄗㄤ");
  ASSERT_EQ(composer.cnvSequence("qtj"), "ㄗㄤˇ");
  ASSERT_EQ(composer.cnvSequence("qtk"), "ㄗㄤˋ");
  ASSERT_EQ(composer.cnvSequence("ql"), "ㄗㄥ");
  ASSERT_EQ(composer.cnvSequence("qlj"), "ㄗㄥˇ");
  ASSERT_EQ(composer.cnvSequence("qlk"), "ㄗㄥˋ");
  ASSERT_EQ(composer.cnvSequence("qx"), "ㄗㄨ");
  ASSERT_EQ(composer.cnvSequence("qxf"), "ㄗㄨˊ");
  ASSERT_EQ(composer.cnvSequence("qxj"), "ㄗㄨˇ");
  ASSERT_EQ(composer.cnvSequence("qxk"), "ㄗㄨˋ");
  ASSERT_EQ(composer.cnvSequence("qxo"), "ㄗㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("qxof"), "ㄗㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("qxoj"), "ㄗㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("qxok"), "ㄗㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("qxod"), "ㄗㄨㄛ˙");
  ASSERT_EQ(composer.cnvSequence("qxq"), "ㄗㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("qxqj"), "ㄗㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("qxqk"), "ㄗㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("qxm"), "ㄗㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("qxmj"), "ㄗㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("qxmk"), "ㄗㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("qxn"), "ㄗㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("qxnj"), "ㄗㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("qxnk"), "ㄗㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("qxl"), "ㄗㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("qxlj"), "ㄗㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("qxlk"), "ㄗㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("w"), "ㄘ");
  ASSERT_EQ(composer.cnvSequence("wf"), "ㄘˊ");
  ASSERT_EQ(composer.cnvSequence("wj"), "ㄘˇ");
  ASSERT_EQ(composer.cnvSequence("wk"), "ㄘˋ");
  ASSERT_EQ(composer.cnvSequence("wa"), "ㄘㄚ");
  ASSERT_EQ(composer.cnvSequence("waj"), "ㄘㄚˇ");
  ASSERT_EQ(composer.cnvSequence("wak"), "ㄘㄚˋ");
  ASSERT_EQ(composer.cnvSequence("wrk"), "ㄘㄜˋ");
  ASSERT_EQ(composer.cnvSequence("wi"), "ㄘㄞ");
  ASSERT_EQ(composer.cnvSequence("wif"), "ㄘㄞˊ");
  ASSERT_EQ(composer.cnvSequence("wij"), "ㄘㄞˇ");
  ASSERT_EQ(composer.cnvSequence("wik"), "ㄘㄞˋ");
  ASSERT_EQ(composer.cnvSequence("wz"), "ㄘㄠ");
  ASSERT_EQ(composer.cnvSequence("wzf"), "ㄘㄠˊ");
  ASSERT_EQ(composer.cnvSequence("wzj"), "ㄘㄠˇ");
  ASSERT_EQ(composer.cnvSequence("wzk"), "ㄘㄠˋ");
  ASSERT_EQ(composer.cnvSequence("wp"), "ㄘㄡ");
  ASSERT_EQ(composer.cnvSequence("wpf"), "ㄘㄡˊ");
  ASSERT_EQ(composer.cnvSequence("wpj"), "ㄘㄡˇ");
  ASSERT_EQ(composer.cnvSequence("wpk"), "ㄘㄡˋ");
  ASSERT_EQ(composer.cnvSequence("wm"), "ㄘㄢ");
  ASSERT_EQ(composer.cnvSequence("wmf"), "ㄘㄢˊ");
  ASSERT_EQ(composer.cnvSequence("wmj"), "ㄘㄢˇ");
  ASSERT_EQ(composer.cnvSequence("wmk"), "ㄘㄢˋ");
  ASSERT_EQ(composer.cnvSequence("wn"), "ㄘㄣ");
  ASSERT_EQ(composer.cnvSequence("wnf"), "ㄘㄣˊ");
  ASSERT_EQ(composer.cnvSequence("wt"), "ㄘㄤ");
  ASSERT_EQ(composer.cnvSequence("wtf"), "ㄘㄤˊ");
  ASSERT_EQ(composer.cnvSequence("wtj"), "ㄘㄤˇ");
  ASSERT_EQ(composer.cnvSequence("wtk"), "ㄘㄤˋ");
  ASSERT_EQ(composer.cnvSequence("wl"), "ㄘㄥ");
  ASSERT_EQ(composer.cnvSequence("wlf"), "ㄘㄥˊ");
  ASSERT_EQ(composer.cnvSequence("wlj"), "ㄘㄥˇ");
  ASSERT_EQ(composer.cnvSequence("wlk"), "ㄘㄥˋ");
  ASSERT_EQ(composer.cnvSequence("wx"), "ㄘㄨ");
  ASSERT_EQ(composer.cnvSequence("wxf"), "ㄘㄨˊ");
  ASSERT_EQ(composer.cnvSequence("wxj"), "ㄘㄨˇ");
  ASSERT_EQ(composer.cnvSequence("wxk"), "ㄘㄨˋ");
  ASSERT_EQ(composer.cnvSequence("wxo"), "ㄘㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("wxof"), "ㄘㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("wxoj"), "ㄘㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("wxok"), "ㄘㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("wxq"), "ㄘㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("wxqj"), "ㄘㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("wxqk"), "ㄘㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("wxm"), "ㄘㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("wxmf"), "ㄘㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("wxmj"), "ㄘㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("wxmk"), "ㄘㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("wxn"), "ㄘㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("wxnf"), "ㄘㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("wxnj"), "ㄘㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("wxnk"), "ㄘㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("wxl"), "ㄘㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("wxlf"), "ㄘㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("wxlj"), "ㄘㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("wxlk"), "ㄘㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("s"), "ㄙ");
  ASSERT_EQ(composer.cnvSequence("sj"), "ㄙˇ");
  ASSERT_EQ(composer.cnvSequence("sk"), "ㄙˋ");
  ASSERT_EQ(composer.cnvSequence("sa"), "ㄙㄚ");
  ASSERT_EQ(composer.cnvSequence("saj"), "ㄙㄚˇ");
  ASSERT_EQ(composer.cnvSequence("sak"), "ㄙㄚˋ");
  ASSERT_EQ(composer.cnvSequence("sad"), "ㄙㄚ˙");
  ASSERT_EQ(composer.cnvSequence("sr"), "ㄙㄜ");
  ASSERT_EQ(composer.cnvSequence("srk"), "ㄙㄜˋ");
  ASSERT_EQ(composer.cnvSequence("si"), "ㄙㄞ");
  ASSERT_EQ(composer.cnvSequence("sif"), "ㄙㄞˊ");
  ASSERT_EQ(composer.cnvSequence("sij"), "ㄙㄞˇ");
  ASSERT_EQ(composer.cnvSequence("sik"), "ㄙㄞˋ");
  ASSERT_EQ(composer.cnvSequence("sq"), "ㄙㄟ");
  ASSERT_EQ(composer.cnvSequence("sz"), "ㄙㄠ");
  ASSERT_EQ(composer.cnvSequence("szj"), "ㄙㄠˇ");
  ASSERT_EQ(composer.cnvSequence("szk"), "ㄙㄠˋ");
  ASSERT_EQ(composer.cnvSequence("sp"), "ㄙㄡ");
  ASSERT_EQ(composer.cnvSequence("spj"), "ㄙㄡˇ");
  ASSERT_EQ(composer.cnvSequence("spk"), "ㄙㄡˋ");
  ASSERT_EQ(composer.cnvSequence("sm"), "ㄙㄢ");
  ASSERT_EQ(composer.cnvSequence("smj"), "ㄙㄢˇ");
  ASSERT_EQ(composer.cnvSequence("smk"), "ㄙㄢˋ");
  ASSERT_EQ(composer.cnvSequence("sn"), "ㄙㄣ");
  ASSERT_EQ(composer.cnvSequence("snj"), "ㄙㄣˇ");
  ASSERT_EQ(composer.cnvSequence("st"), "ㄙㄤ");
  ASSERT_EQ(composer.cnvSequence("stj"), "ㄙㄤˇ");
  ASSERT_EQ(composer.cnvSequence("stk"), "ㄙㄤˋ");
  ASSERT_EQ(composer.cnvSequence("sl"), "ㄙㄥ");
  ASSERT_EQ(composer.cnvSequence("slk"), "ㄙㄥˋ");
  ASSERT_EQ(composer.cnvSequence("sx"), "ㄙㄨ");
  ASSERT_EQ(composer.cnvSequence("sxf"), "ㄙㄨˊ");
  ASSERT_EQ(composer.cnvSequence("sxj"), "ㄙㄨˇ");
  ASSERT_EQ(composer.cnvSequence("sxk"), "ㄙㄨˋ");
  ASSERT_EQ(composer.cnvSequence("sxo"), "ㄙㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("sxof"), "ㄙㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("sxoj"), "ㄙㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("sxok"), "ㄙㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("sxq"), "ㄙㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("sxqf"), "ㄙㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("sxqj"), "ㄙㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("sxqk"), "ㄙㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("sxm"), "ㄙㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("sxmj"), "ㄙㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("sxmk"), "ㄙㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("sxn"), "ㄙㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("sxnj"), "ㄙㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("sxnk"), "ㄙㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("sxl"), "ㄙㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("sxlf"), "ㄙㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("sxlj"), "ㄙㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("sxlk"), "ㄙㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("a"), "ㄚ");
  ASSERT_EQ(composer.cnvSequence("af"), "ㄚˊ");
  ASSERT_EQ(composer.cnvSequence("ak"), "ㄚˋ");
  ASSERT_EQ(composer.cnvSequence("ad"), "ㄚ˙");
  ASSERT_EQ(composer.cnvSequence("o"), "ㄛ");
  ASSERT_EQ(composer.cnvSequence("of"), "ㄛˊ");
  ASSERT_EQ(composer.cnvSequence("oj"), "ㄛˇ");
  ASSERT_EQ(composer.cnvSequence("ok"), "ㄛˋ");
  ASSERT_EQ(composer.cnvSequence("r"), "ㄜ");
  ASSERT_EQ(composer.cnvSequence("rf"), "ㄜˊ");
  ASSERT_EQ(composer.cnvSequence("rj"), "ㄜˇ");
  ASSERT_EQ(composer.cnvSequence("rk"), "ㄜˋ");
  // ASSERT_EQ(composer.cnvSequence("wf"), "ㄝˊ");
  // ASSERT_EQ(composer.cnvSequence("wj"), "ㄝˇ");
  // ASSERT_EQ(composer.cnvSequence("wk"), "ㄝˋ");
  // ASSERT_EQ(composer.cnvSequence("wd"), "ㄝ˙");
  ASSERT_EQ(composer.cnvSequence("i"), "ㄞ");
  ASSERT_EQ(composer.cnvSequence("if"), "ㄞˊ");
  ASSERT_EQ(composer.cnvSequence("ij"), "ㄞˇ");
  ASSERT_EQ(composer.cnvSequence("ik"), "ㄞˋ");
  // ASSERT_EQ(composer.cnvSequence("qk"), "ㄟˋ");
  ASSERT_EQ(composer.cnvSequence("z"), "ㄠ");
  ASSERT_EQ(composer.cnvSequence("zf"), "ㄠˊ");
  ASSERT_EQ(composer.cnvSequence("zj"), "ㄠˇ");
  ASSERT_EQ(composer.cnvSequence("zk"), "ㄠˋ");
  ASSERT_EQ(composer.cnvSequence("p"), "ㄡ");
  ASSERT_EQ(composer.cnvSequence("pf"), "ㄡˊ");
  ASSERT_EQ(composer.cnvSequence("pj"), "ㄡˇ");
  ASSERT_EQ(composer.cnvSequence("pk"), "ㄡˋ");
  ASSERT_EQ(composer.cnvSequence("pd"), "ㄡ˙");
  ASSERT_EQ(composer.cnvSequence("m"), "ㄢ");
  ASSERT_EQ(composer.cnvSequence("mf"), "ㄢˊ");
  ASSERT_EQ(composer.cnvSequence("mj"), "ㄢˇ");
  ASSERT_EQ(composer.cnvSequence("mk"), "ㄢˋ");
  ASSERT_EQ(composer.cnvSequence("n"), "ㄣ");
  ASSERT_EQ(composer.cnvSequence("nf"), "ㄣˊ");
  ASSERT_EQ(composer.cnvSequence("nj"), "ㄣˇ");
  ASSERT_EQ(composer.cnvSequence("nk"), "ㄣˋ");
  ASSERT_EQ(composer.cnvSequence("nd"), "ㄣ˙");
  ASSERT_EQ(composer.cnvSequence("t"), "ㄤ");
  ASSERT_EQ(composer.cnvSequence("tf"), "ㄤˊ");
  ASSERT_EQ(composer.cnvSequence("tj"), "ㄤˇ");
  ASSERT_EQ(composer.cnvSequence("tk"), "ㄤˋ");
  ASSERT_EQ(composer.cnvSequence("l"), "ㄥ");
  ASSERT_EQ(composer.cnvSequence("lk"), "ㄥˋ");
  ASSERT_EQ(composer.cnvSequence("h"), "ㄦ");
  ASSERT_EQ(composer.cnvSequence("hf"), "ㄦˊ");
  ASSERT_EQ(composer.cnvSequence("hj"), "ㄦˇ");
  ASSERT_EQ(composer.cnvSequence("hk"), "ㄦˋ");
  ASSERT_EQ(composer.cnvSequence("hd"), "ㄦ˙");
  ASSERT_EQ(composer.cnvSequence("e"), "ㄧ");
  ASSERT_EQ(composer.cnvSequence("ef"), "ㄧˊ");
  ASSERT_EQ(composer.cnvSequence("ej"), "ㄧˇ");
  ASSERT_EQ(composer.cnvSequence("ek"), "ㄧˋ");
  ASSERT_EQ(composer.cnvSequence("ea"), "ㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("eaf"), "ㄧㄚˊ");
  ASSERT_EQ(composer.cnvSequence("eaj"), "ㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("eak"), "ㄧㄚˋ");
  ASSERT_EQ(composer.cnvSequence("ead"), "ㄧㄚ˙");
  ASSERT_EQ(composer.cnvSequence("eo"), "ㄧㄛ");
  ASSERT_EQ(composer.cnvSequence("eod"), "ㄧㄛ˙");
  ASSERT_EQ(composer.cnvSequence("ew"), "ㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("ewf"), "ㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("ewj"), "ㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("ewk"), "ㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("ewd"), "ㄧㄝ˙");
  ASSERT_EQ(composer.cnvSequence("eif"), "ㄧㄞˊ");
  ASSERT_EQ(composer.cnvSequence("ez"), "ㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("ezf"), "ㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("ezj"), "ㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("ezk"), "ㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("ep"), "ㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("epf"), "ㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("epj"), "ㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("epk"), "ㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("em"), "ㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("emf"), "ㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("emj"), "ㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("emk"), "ㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("en"), "ㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("enf"), "ㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("enj"), "ㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("enk"), "ㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("et"), "ㄧㄤ");
  ASSERT_EQ(composer.cnvSequence("etf"), "ㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("etj"), "ㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("etk"), "ㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("el"), "ㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("elf"), "ㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("elj"), "ㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("elk"), "ㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("x"), "ㄨ");
  ASSERT_EQ(composer.cnvSequence("xf"), "ㄨˊ");
  ASSERT_EQ(composer.cnvSequence("xj"), "ㄨˇ");
  ASSERT_EQ(composer.cnvSequence("xk"), "ㄨˋ");
  ASSERT_EQ(composer.cnvSequence("xa"), "ㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("xaf"), "ㄨㄚˊ");
  ASSERT_EQ(composer.cnvSequence("xaj"), "ㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("xak"), "ㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("xad"), "ㄨㄚ˙");
  ASSERT_EQ(composer.cnvSequence("xo"), "ㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("xoj"), "ㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("xok"), "ㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("xi"), "ㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("xij"), "ㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("xik"), "ㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("xq"), "ㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("xqf"), "ㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("xqj"), "ㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("xqk"), "ㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("xm"), "ㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("xmf"), "ㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("xmj"), "ㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("xmk"), "ㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("xn"), "ㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("xnf"), "ㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("xnj"), "ㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("xnk"), "ㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("xt"), "ㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("xtf"), "ㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("xtj"), "ㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("xtk"), "ㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("xl"), "ㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("xlj"), "ㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("xlk"), "ㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("u"), "ㄩ");
  ASSERT_EQ(composer.cnvSequence("uf"), "ㄩˊ");
  ASSERT_EQ(composer.cnvSequence("uj"), "ㄩˇ");
  ASSERT_EQ(composer.cnvSequence("uk"), "ㄩˋ");
  ASSERT_EQ(composer.cnvSequence("uw"), "ㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("uwj"), "ㄩㄝˇ");
  ASSERT_EQ(composer.cnvSequence("uwk"), "ㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("um"), "ㄩㄢ");
  ASSERT_EQ(composer.cnvSequence("umf"), "ㄩㄢˊ");
  ASSERT_EQ(composer.cnvSequence("umj"), "ㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("umk"), "ㄩㄢˋ");
  ASSERT_EQ(composer.cnvSequence("un"), "ㄩㄣ");
  ASSERT_EQ(composer.cnvSequence("unf"), "ㄩㄣˊ");
  ASSERT_EQ(composer.cnvSequence("unj"), "ㄩㄣˇ");
  ASSERT_EQ(composer.cnvSequence("unk"), "ㄩㄣˋ");
  ASSERT_EQ(composer.cnvSequence("ul"), "ㄩㄥ");
  ASSERT_EQ(composer.cnvSequence("ulf"), "ㄩㄥˊ");
  ASSERT_EQ(composer.cnvSequence("ulj"), "ㄩㄥˇ");
  ASSERT_EQ(composer.cnvSequence("ulk"), "ㄩㄥˋ");
}
TEST(MandarinTestAdvanced, Hsu) {
  // 許氏鍵盤窮極測試;
  BopomofoReadingBuffer composer(BopomofoKeyboardLayout::HsuLayout());
  ASSERT_EQ(composer.cnvSequence("kek"), "ㄎㄧㄤ");
  // AreEqual(Composer.cnvSequence("vezf"), "ㄍㄧㄠˊ");
  // AreEqual(Composer.cnvSequence("gen"), "ㄍㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("bekd"), "ㄅㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("bekj"), "ㄅㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("dxk"), "ㄉㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("by"), "ㄅㄚ");
  ASSERT_EQ(composer.cnvSequence("byd"), "ㄅㄚˊ");
  ASSERT_EQ(composer.cnvSequence("byf"), "ㄅㄚˇ");
  ASSERT_EQ(composer.cnvSequence("byj"), "ㄅㄚˋ");
  ASSERT_EQ(composer.cnvSequence("bys"), "ㄅㄚ˙");
  ASSERT_EQ(composer.cnvSequence("bh"), "ㄅㄛ");
  ASSERT_EQ(composer.cnvSequence("bhd"), "ㄅㄛˊ");
  ASSERT_EQ(composer.cnvSequence("bhf"), "ㄅㄛˇ");
  ASSERT_EQ(composer.cnvSequence("bhj"), "ㄅㄛˋ");
  ASSERT_EQ(composer.cnvSequence("bhs"), "ㄅㄛ˙");
  ASSERT_EQ(composer.cnvSequence("bi"), "ㄅㄞ");
  ASSERT_EQ(composer.cnvSequence("bid"), "ㄅㄞˊ");
  ASSERT_EQ(composer.cnvSequence("bif"), "ㄅㄞˇ");
  ASSERT_EQ(composer.cnvSequence("bij"), "ㄅㄞˋ");
  ASSERT_EQ(composer.cnvSequence("bis"), "ㄅㄞ˙");
  ASSERT_EQ(composer.cnvSequence("ba"), "ㄅㄟ");
  ASSERT_EQ(composer.cnvSequence("baf"), "ㄅㄟˇ");
  ASSERT_EQ(composer.cnvSequence("baj"), "ㄅㄟˋ");
  ASSERT_EQ(composer.cnvSequence("bas"), "ㄅㄟ˙");
  ASSERT_EQ(composer.cnvSequence("bw"), "ㄅㄠ");
  ASSERT_EQ(composer.cnvSequence("bwd"), "ㄅㄠˊ");
  ASSERT_EQ(composer.cnvSequence("bwf"), "ㄅㄠˇ");
  ASSERT_EQ(composer.cnvSequence("bwj"), "ㄅㄠˋ");
  ASSERT_EQ(composer.cnvSequence("bm"), "ㄅㄢ");
  ASSERT_EQ(composer.cnvSequence("bmf"), "ㄅㄢˇ");
  ASSERT_EQ(composer.cnvSequence("bmj"), "ㄅㄢˋ");
  ASSERT_EQ(composer.cnvSequence("bn"), "ㄅㄣ");
  ASSERT_EQ(composer.cnvSequence("bnf"), "ㄅㄣˇ");
  ASSERT_EQ(composer.cnvSequence("bnj"), "ㄅㄣˋ");
  ASSERT_EQ(composer.cnvSequence("bk"), "ㄅㄤ");
  ASSERT_EQ(composer.cnvSequence("bkf"), "ㄅㄤˇ");
  ASSERT_EQ(composer.cnvSequence("bkj"), "ㄅㄤˋ");
  ASSERT_EQ(composer.cnvSequence("bl"), "ㄅㄥ");
  ASSERT_EQ(composer.cnvSequence("bld"), "ㄅㄥˊ");
  ASSERT_EQ(composer.cnvSequence("blf"), "ㄅㄥˇ");
  ASSERT_EQ(composer.cnvSequence("blj"), "ㄅㄥˋ");
  ASSERT_EQ(composer.cnvSequence("be"), "ㄅㄧ");
  ASSERT_EQ(composer.cnvSequence("bed"), "ㄅㄧˊ");
  ASSERT_EQ(composer.cnvSequence("bef"), "ㄅㄧˇ");
  ASSERT_EQ(composer.cnvSequence("bej"), "ㄅㄧˋ");
  ASSERT_EQ(composer.cnvSequence("bee"), "ㄅㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("beed"), "ㄅㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("beef"), "ㄅㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("beej"), "ㄅㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("bew"), "ㄅㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("bewf"), "ㄅㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("bewj"), "ㄅㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("bem"), "ㄅㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("bemd"), "ㄅㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("bemf"), "ㄅㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("bemj"), "ㄅㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("ben"), "ㄅㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("benf"), "ㄅㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("benj"), "ㄅㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("bel"), "ㄅㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("belf"), "ㄅㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("belj"), "ㄅㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("bx"), "ㄅㄨ");
  ASSERT_EQ(composer.cnvSequence("bxd"), "ㄅㄨˊ");
  ASSERT_EQ(composer.cnvSequence("bxf"), "ㄅㄨˇ");
  ASSERT_EQ(composer.cnvSequence("bxj"), "ㄅㄨˋ");
  ASSERT_EQ(composer.cnvSequence("py"), "ㄆㄚ");
  ASSERT_EQ(composer.cnvSequence("pyd"), "ㄆㄚˊ");
  ASSERT_EQ(composer.cnvSequence("pyf"), "ㄆㄚˇ");
  ASSERT_EQ(composer.cnvSequence("pyj"), "ㄆㄚˋ");
  ASSERT_EQ(composer.cnvSequence("pys"), "ㄆㄚ˙");
  ASSERT_EQ(composer.cnvSequence("ph"), "ㄆㄛ");
  ASSERT_EQ(composer.cnvSequence("phd"), "ㄆㄛˊ");
  ASSERT_EQ(composer.cnvSequence("phf"), "ㄆㄛˇ");
  ASSERT_EQ(composer.cnvSequence("phj"), "ㄆㄛˋ");
  ASSERT_EQ(composer.cnvSequence("pi"), "ㄆㄞ");
  ASSERT_EQ(composer.cnvSequence("pid"), "ㄆㄞˊ");
  ASSERT_EQ(composer.cnvSequence("pif"), "ㄆㄞˇ");
  ASSERT_EQ(composer.cnvSequence("pij"), "ㄆㄞˋ");
  ASSERT_EQ(composer.cnvSequence("pa"), "ㄆㄟ");
  ASSERT_EQ(composer.cnvSequence("pad"), "ㄆㄟˊ");
  ASSERT_EQ(composer.cnvSequence("paf"), "ㄆㄟˇ");
  ASSERT_EQ(composer.cnvSequence("paj"), "ㄆㄟˋ");
  ASSERT_EQ(composer.cnvSequence("pw"), "ㄆㄠ");
  ASSERT_EQ(composer.cnvSequence("pwd"), "ㄆㄠˊ");
  ASSERT_EQ(composer.cnvSequence("pwf"), "ㄆㄠˇ");
  ASSERT_EQ(composer.cnvSequence("pwj"), "ㄆㄠˋ");
  ASSERT_EQ(composer.cnvSequence("po"), "ㄆㄡ");
  ASSERT_EQ(composer.cnvSequence("pod"), "ㄆㄡˊ");
  ASSERT_EQ(composer.cnvSequence("pof"), "ㄆㄡˇ");
  ASSERT_EQ(composer.cnvSequence("poj"), "ㄆㄡˋ");
  ASSERT_EQ(composer.cnvSequence("pm"), "ㄆㄢ");
  ASSERT_EQ(composer.cnvSequence("pmd"), "ㄆㄢˊ");
  ASSERT_EQ(composer.cnvSequence("pmf"), "ㄆㄢˇ");
  ASSERT_EQ(composer.cnvSequence("pmj"), "ㄆㄢˋ");
  ASSERT_EQ(composer.cnvSequence("pn"), "ㄆㄣ");
  ASSERT_EQ(composer.cnvSequence("pnd"), "ㄆㄣˊ");
  ASSERT_EQ(composer.cnvSequence("pnf"), "ㄆㄣˇ");
  ASSERT_EQ(composer.cnvSequence("pnj"), "ㄆㄣˋ");
  ASSERT_EQ(composer.cnvSequence("pk"), "ㄆㄤ");
  ASSERT_EQ(composer.cnvSequence("pkd"), "ㄆㄤˊ");
  ASSERT_EQ(composer.cnvSequence("pkf"), "ㄆㄤˇ");
  ASSERT_EQ(composer.cnvSequence("pkj"), "ㄆㄤˋ");
  ASSERT_EQ(composer.cnvSequence("pl"), "ㄆㄥ");
  ASSERT_EQ(composer.cnvSequence("pld"), "ㄆㄥˊ");
  ASSERT_EQ(composer.cnvSequence("plf"), "ㄆㄥˇ");
  ASSERT_EQ(composer.cnvSequence("plj"), "ㄆㄥˋ");
  ASSERT_EQ(composer.cnvSequence("pe"), "ㄆㄧ");
  ASSERT_EQ(composer.cnvSequence("ped"), "ㄆㄧˊ");
  ASSERT_EQ(composer.cnvSequence("pef"), "ㄆㄧˇ");
  ASSERT_EQ(composer.cnvSequence("pej"), "ㄆㄧˋ");
  ASSERT_EQ(composer.cnvSequence("pey"), "ㄆㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("pee"), "ㄆㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("peef"), "ㄆㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("peej"), "ㄆㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("pew"), "ㄆㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("pewd"), "ㄆㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("pewf"), "ㄆㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("pewj"), "ㄆㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("pem"), "ㄆㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("pemd"), "ㄆㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("pemf"), "ㄆㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("pemj"), "ㄆㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("pen"), "ㄆㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("pend"), "ㄆㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("penf"), "ㄆㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("penj"), "ㄆㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("pel"), "ㄆㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("peld"), "ㄆㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("pelf"), "ㄆㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("pelj"), "ㄆㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("px"), "ㄆㄨ");
  ASSERT_EQ(composer.cnvSequence("pxd"), "ㄆㄨˊ");
  ASSERT_EQ(composer.cnvSequence("pxf"), "ㄆㄨˇ");
  ASSERT_EQ(composer.cnvSequence("pxj"), "ㄆㄨˋ");
  ASSERT_EQ(composer.cnvSequence("my"), "ㄇㄚ");
  ASSERT_EQ(composer.cnvSequence("myd"), "ㄇㄚˊ");
  ASSERT_EQ(composer.cnvSequence("myf"), "ㄇㄚˇ");
  ASSERT_EQ(composer.cnvSequence("myj"), "ㄇㄚˋ");
  ASSERT_EQ(composer.cnvSequence("mys"), "ㄇㄚ˙");
  ASSERT_EQ(composer.cnvSequence("mh"), "ㄇㄛ");
  ASSERT_EQ(composer.cnvSequence("mhd"), "ㄇㄛˊ");
  ASSERT_EQ(composer.cnvSequence("mhf"), "ㄇㄛˇ");
  ASSERT_EQ(composer.cnvSequence("mhj"), "ㄇㄛˋ");
  ASSERT_EQ(composer.cnvSequence("mhs"), "ㄇㄛ˙");
  ASSERT_EQ(composer.cnvSequence("mg"), "ㄇㄜ");
  ASSERT_EQ(composer.cnvSequence("mgj"), "ㄇㄜˋ");
  ASSERT_EQ(composer.cnvSequence("mgs"), "ㄇㄜ˙");
  ASSERT_EQ(composer.cnvSequence("mi"), "ㄇㄞ");
  ASSERT_EQ(composer.cnvSequence("mid"), "ㄇㄞˊ");
  ASSERT_EQ(composer.cnvSequence("mif"), "ㄇㄞˇ");
  ASSERT_EQ(composer.cnvSequence("mij"), "ㄇㄞˋ");
  ASSERT_EQ(composer.cnvSequence("mad"), "ㄇㄟˊ");
  ASSERT_EQ(composer.cnvSequence("maf"), "ㄇㄟˇ");
  ASSERT_EQ(composer.cnvSequence("maj"), "ㄇㄟˋ");
  ASSERT_EQ(composer.cnvSequence("mw"), "ㄇㄠ");
  ASSERT_EQ(composer.cnvSequence("mwd"), "ㄇㄠˊ");
  ASSERT_EQ(composer.cnvSequence("mwf"), "ㄇㄠˇ");
  ASSERT_EQ(composer.cnvSequence("mwj"), "ㄇㄠˋ");
  ASSERT_EQ(composer.cnvSequence("mod"), "ㄇㄡˊ");
  ASSERT_EQ(composer.cnvSequence("mof"), "ㄇㄡˇ");
  ASSERT_EQ(composer.cnvSequence("moj"), "ㄇㄡˋ");
  ASSERT_EQ(composer.cnvSequence("mm"), "ㄇㄢ");
  ASSERT_EQ(composer.cnvSequence("mmd"), "ㄇㄢˊ");
  ASSERT_EQ(composer.cnvSequence("mmf"), "ㄇㄢˇ");
  ASSERT_EQ(composer.cnvSequence("mmj"), "ㄇㄢˋ");
  ASSERT_EQ(composer.cnvSequence("mn"), "ㄇㄣ");
  ASSERT_EQ(composer.cnvSequence("mnd"), "ㄇㄣˊ");
  ASSERT_EQ(composer.cnvSequence("mnf"), "ㄇㄣˇ");
  ASSERT_EQ(composer.cnvSequence("mnj"), "ㄇㄣˋ");
  ASSERT_EQ(composer.cnvSequence("mns"), "ㄇㄣ˙");
  ASSERT_EQ(composer.cnvSequence("mk"), "ㄇㄤ");
  ASSERT_EQ(composer.cnvSequence("mkd"), "ㄇㄤˊ");
  ASSERT_EQ(composer.cnvSequence("mkf"), "ㄇㄤˇ");
  ASSERT_EQ(composer.cnvSequence("mkj"), "ㄇㄤˋ");
  ASSERT_EQ(composer.cnvSequence("ml"), "ㄇㄥ");
  ASSERT_EQ(composer.cnvSequence("mld"), "ㄇㄥˊ");
  ASSERT_EQ(composer.cnvSequence("mlf"), "ㄇㄥˇ");
  ASSERT_EQ(composer.cnvSequence("mlj"), "ㄇㄥˋ");
  ASSERT_EQ(composer.cnvSequence("me"), "ㄇㄧ");
  ASSERT_EQ(composer.cnvSequence("med"), "ㄇㄧˊ");
  ASSERT_EQ(composer.cnvSequence("mef"), "ㄇㄧˇ");
  ASSERT_EQ(composer.cnvSequence("mej"), "ㄇㄧˋ");
  ASSERT_EQ(composer.cnvSequence("mee"), "ㄇㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("meed"), "ㄇㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("meej"), "ㄇㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("mew"), "ㄇㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("mewd"), "ㄇㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("mewf"), "ㄇㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("mewj"), "ㄇㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("meod"), "ㄇㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("meof"), "ㄇㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("meoj"), "ㄇㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("mem"), "ㄇㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("memd"), "ㄇㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("memf"), "ㄇㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("memj"), "ㄇㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("men"), "ㄇㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("mend"), "ㄇㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("menf"), "ㄇㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("meld"), "ㄇㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("melf"), "ㄇㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("melj"), "ㄇㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("mxd"), "ㄇㄨˊ");
  ASSERT_EQ(composer.cnvSequence("mxf"), "ㄇㄨˇ");
  ASSERT_EQ(composer.cnvSequence("mxj"), "ㄇㄨˋ");
  ASSERT_EQ(composer.cnvSequence("fy"), "ㄈㄚ");
  ASSERT_EQ(composer.cnvSequence("fyd"), "ㄈㄚˊ");
  ASSERT_EQ(composer.cnvSequence("fyf"), "ㄈㄚˇ");
  ASSERT_EQ(composer.cnvSequence("fyj"), "ㄈㄚˋ");
  ASSERT_EQ(composer.cnvSequence("fhd"), "ㄈㄛˊ");
  ASSERT_EQ(composer.cnvSequence("fa"), "ㄈㄟ");
  ASSERT_EQ(composer.cnvSequence("fad"), "ㄈㄟˊ");
  ASSERT_EQ(composer.cnvSequence("faf"), "ㄈㄟˇ");
  ASSERT_EQ(composer.cnvSequence("faj"), "ㄈㄟˋ");
  ASSERT_EQ(composer.cnvSequence("fo"), "ㄈㄡ");
  ASSERT_EQ(composer.cnvSequence("fod"), "ㄈㄡˊ");
  ASSERT_EQ(composer.cnvSequence("fof"), "ㄈㄡˇ");
  ASSERT_EQ(composer.cnvSequence("foj"), "ㄈㄡˋ");
  ASSERT_EQ(composer.cnvSequence("fm"), "ㄈㄢ");
  ASSERT_EQ(composer.cnvSequence("fmd"), "ㄈㄢˊ");
  ASSERT_EQ(composer.cnvSequence("fmf"), "ㄈㄢˇ");
  ASSERT_EQ(composer.cnvSequence("fmj"), "ㄈㄢˋ");
  ASSERT_EQ(composer.cnvSequence("fn"), "ㄈㄣ");
  ASSERT_EQ(composer.cnvSequence("fnd"), "ㄈㄣˊ");
  ASSERT_EQ(composer.cnvSequence("fnf"), "ㄈㄣˇ");
  ASSERT_EQ(composer.cnvSequence("fnj"), "ㄈㄣˋ");
  ASSERT_EQ(composer.cnvSequence("fns"), "ㄈㄣ˙");
  ASSERT_EQ(composer.cnvSequence("fk"), "ㄈㄤ");
  ASSERT_EQ(composer.cnvSequence("fkd"), "ㄈㄤˊ");
  ASSERT_EQ(composer.cnvSequence("fkf"), "ㄈㄤˇ");
  ASSERT_EQ(composer.cnvSequence("fkj"), "ㄈㄤˋ");
  ASSERT_EQ(composer.cnvSequence("fl"), "ㄈㄥ");
  ASSERT_EQ(composer.cnvSequence("fld"), "ㄈㄥˊ");
  ASSERT_EQ(composer.cnvSequence("flf"), "ㄈㄥˇ");
  ASSERT_EQ(composer.cnvSequence("flj"), "ㄈㄥˋ");
  ASSERT_EQ(composer.cnvSequence("fewj"), "ㄈㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("fx"), "ㄈㄨ");
  ASSERT_EQ(composer.cnvSequence("fxd"), "ㄈㄨˊ");
  ASSERT_EQ(composer.cnvSequence("fxf"), "ㄈㄨˇ");
  ASSERT_EQ(composer.cnvSequence("fxj"), "ㄈㄨˋ");
  ASSERT_EQ(composer.cnvSequence("dy"), "ㄉㄚ");
  ASSERT_EQ(composer.cnvSequence("dyd"), "ㄉㄚˊ");
  ASSERT_EQ(composer.cnvSequence("dyf"), "ㄉㄚˇ");
  ASSERT_EQ(composer.cnvSequence("dyj"), "ㄉㄚˋ");
  ASSERT_EQ(composer.cnvSequence("dys"), "ㄉㄚ˙");
  ASSERT_EQ(composer.cnvSequence("dg"), "ㄉㄜ");
  ASSERT_EQ(composer.cnvSequence("dgd"), "ㄉㄜˊ");
  ASSERT_EQ(composer.cnvSequence("dgs"), "ㄉㄜ˙");
  ASSERT_EQ(composer.cnvSequence("di"), "ㄉㄞ");
  ASSERT_EQ(composer.cnvSequence("dif"), "ㄉㄞˇ");
  ASSERT_EQ(composer.cnvSequence("dij"), "ㄉㄞˋ");
  ASSERT_EQ(composer.cnvSequence("daf"), "ㄉㄟˇ");
  ASSERT_EQ(composer.cnvSequence("dw"), "ㄉㄠ");
  ASSERT_EQ(composer.cnvSequence("dwd"), "ㄉㄠˊ");
  ASSERT_EQ(composer.cnvSequence("dwf"), "ㄉㄠˇ");
  ASSERT_EQ(composer.cnvSequence("dwj"), "ㄉㄠˋ");
  ASSERT_EQ(composer.cnvSequence("do"), "ㄉㄡ");
  ASSERT_EQ(composer.cnvSequence("dod"), "ㄉㄡˊ");
  ASSERT_EQ(composer.cnvSequence("dof"), "ㄉㄡˇ");
  ASSERT_EQ(composer.cnvSequence("doj"), "ㄉㄡˋ");
  ASSERT_EQ(composer.cnvSequence("dm"), "ㄉㄢ");
  ASSERT_EQ(composer.cnvSequence("dmf"), "ㄉㄢˇ");
  ASSERT_EQ(composer.cnvSequence("dmj"), "ㄉㄢˋ");
  ASSERT_EQ(composer.cnvSequence("dnj"), "ㄉㄣˋ");
  ASSERT_EQ(composer.cnvSequence("dk"), "ㄉㄤ");
  ASSERT_EQ(composer.cnvSequence("dkf"), "ㄉㄤˇ");
  ASSERT_EQ(composer.cnvSequence("dkj"), "ㄉㄤˋ");
  ASSERT_EQ(composer.cnvSequence("dl"), "ㄉㄥ");
  ASSERT_EQ(composer.cnvSequence("dlf"), "ㄉㄥˇ");
  ASSERT_EQ(composer.cnvSequence("dlj"), "ㄉㄥˋ");
  ASSERT_EQ(composer.cnvSequence("de"), "ㄉㄧ");
  ASSERT_EQ(composer.cnvSequence("ded"), "ㄉㄧˊ");
  ASSERT_EQ(composer.cnvSequence("def"), "ㄉㄧˇ");
  ASSERT_EQ(composer.cnvSequence("dej"), "ㄉㄧˋ");
  ASSERT_EQ(composer.cnvSequence("deyf"), "ㄉㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("dee"), "ㄉㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("deed"), "ㄉㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("deef"), "ㄉㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("deej"), "ㄉㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("dew"), "ㄉㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("dewf"), "ㄉㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("dewj"), "ㄉㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("deo"), "ㄉㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("dem"), "ㄉㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("demd"), "ㄉㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("demf"), "ㄉㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("demj"), "ㄉㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("del"), "ㄉㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("deld"), "ㄉㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("delf"), "ㄉㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("delj"), "ㄉㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("dx"), "ㄉㄨ");
  ASSERT_EQ(composer.cnvSequence("dxd"), "ㄉㄨˊ");
  ASSERT_EQ(composer.cnvSequence("dxf"), "ㄉㄨˇ");
  ASSERT_EQ(composer.cnvSequence("dxj"), "ㄉㄨˋ");
  ASSERT_EQ(composer.cnvSequence("dxh"), "ㄉㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("dxhd"), "ㄉㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("dxhf"), "ㄉㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("dxhj"), "ㄉㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("dxhs"), "ㄉㄨㄛ˙");
  ASSERT_EQ(composer.cnvSequence("dxa"), "ㄉㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("dxaf"), "ㄉㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("dxaj"), "ㄉㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("dxm"), "ㄉㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("dxmf"), "ㄉㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("dxmj"), "ㄉㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("dxn"), "ㄉㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("dxnf"), "ㄉㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("dxnj"), "ㄉㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("dxl"), "ㄉㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("dxlf"), "ㄉㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("dxlj"), "ㄉㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ty"), "ㄊㄚ");
  ASSERT_EQ(composer.cnvSequence("tyf"), "ㄊㄚˇ");
  ASSERT_EQ(composer.cnvSequence("tyj"), "ㄊㄚˋ");
  ASSERT_EQ(composer.cnvSequence("tgj"), "ㄊㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ti"), "ㄊㄞ");
  ASSERT_EQ(composer.cnvSequence("tid"), "ㄊㄞˊ");
  ASSERT_EQ(composer.cnvSequence("tif"), "ㄊㄞˇ");
  ASSERT_EQ(composer.cnvSequence("tij"), "ㄊㄞˋ");
  ASSERT_EQ(composer.cnvSequence("tis"), "ㄊㄞ˙");
  ASSERT_EQ(composer.cnvSequence("tw"), "ㄊㄠ");
  ASSERT_EQ(composer.cnvSequence("twd"), "ㄊㄠˊ");
  ASSERT_EQ(composer.cnvSequence("twf"), "ㄊㄠˇ");
  ASSERT_EQ(composer.cnvSequence("twj"), "ㄊㄠˋ");
  ASSERT_EQ(composer.cnvSequence("tws"), "ㄊㄠ˙");
  ASSERT_EQ(composer.cnvSequence("to"), "ㄊㄡ");
  ASSERT_EQ(composer.cnvSequence("tod"), "ㄊㄡˊ");
  ASSERT_EQ(composer.cnvSequence("tof"), "ㄊㄡˇ");
  ASSERT_EQ(composer.cnvSequence("toj"), "ㄊㄡˋ");
  ASSERT_EQ(composer.cnvSequence("tos"), "ㄊㄡ˙");
  ASSERT_EQ(composer.cnvSequence("tm"), "ㄊㄢ");
  ASSERT_EQ(composer.cnvSequence("tmd"), "ㄊㄢˊ");
  ASSERT_EQ(composer.cnvSequence("tmf"), "ㄊㄢˇ");
  ASSERT_EQ(composer.cnvSequence("tmj"), "ㄊㄢˋ");
  ASSERT_EQ(composer.cnvSequence("tk"), "ㄊㄤ");
  ASSERT_EQ(composer.cnvSequence("tkd"), "ㄊㄤˊ");
  ASSERT_EQ(composer.cnvSequence("tkf"), "ㄊㄤˇ");
  ASSERT_EQ(composer.cnvSequence("tkj"), "ㄊㄤˋ");
  ASSERT_EQ(composer.cnvSequence("tl"), "ㄊㄥ");
  ASSERT_EQ(composer.cnvSequence("tld"), "ㄊㄥˊ");
  ASSERT_EQ(composer.cnvSequence("tlj"), "ㄊㄥˋ");
  ASSERT_EQ(composer.cnvSequence("te"), "ㄊㄧ");
  ASSERT_EQ(composer.cnvSequence("ted"), "ㄊㄧˊ");
  ASSERT_EQ(composer.cnvSequence("tef"), "ㄊㄧˇ");
  ASSERT_EQ(composer.cnvSequence("tej"), "ㄊㄧˋ");
  ASSERT_EQ(composer.cnvSequence("tee"), "ㄊㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("teed"), "ㄊㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("teef"), "ㄊㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("teej"), "ㄊㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("tew"), "ㄊㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("tewd"), "ㄊㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("tewf"), "ㄊㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("tewj"), "ㄊㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("tem"), "ㄊㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("temd"), "ㄊㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("temf"), "ㄊㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("temj"), "ㄊㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("tel"), "ㄊㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("teld"), "ㄊㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("telf"), "ㄊㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("telj"), "ㄊㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("tx"), "ㄊㄨ");
  ASSERT_EQ(composer.cnvSequence("txd"), "ㄊㄨˊ");
  ASSERT_EQ(composer.cnvSequence("txf"), "ㄊㄨˇ");
  ASSERT_EQ(composer.cnvSequence("txj"), "ㄊㄨˋ");
  ASSERT_EQ(composer.cnvSequence("txh"), "ㄊㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("txhd"), "ㄊㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("txhf"), "ㄊㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("txhj"), "ㄊㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("txa"), "ㄊㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("txad"), "ㄊㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("txaf"), "ㄊㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("txaj"), "ㄊㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("txm"), "ㄊㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("txmd"), "ㄊㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("txmf"), "ㄊㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("txmj"), "ㄊㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("txn"), "ㄊㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("txnd"), "ㄊㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("txnf"), "ㄊㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("txnj"), "ㄊㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("txl"), "ㄊㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("txld"), "ㄊㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("txlf"), "ㄊㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("txlj"), "ㄊㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ny"), "ㄋㄚ");
  ASSERT_EQ(composer.cnvSequence("nyd"), "ㄋㄚˊ");
  ASSERT_EQ(composer.cnvSequence("nyf"), "ㄋㄚˇ");
  ASSERT_EQ(composer.cnvSequence("nyj"), "ㄋㄚˋ");
  ASSERT_EQ(composer.cnvSequence("nys"), "ㄋㄚ˙");
  ASSERT_EQ(composer.cnvSequence("ngj"), "ㄋㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ngs"), "ㄋㄜ˙");
  ASSERT_EQ(composer.cnvSequence("nid"), "ㄋㄞˊ");
  ASSERT_EQ(composer.cnvSequence("nif"), "ㄋㄞˇ");
  ASSERT_EQ(composer.cnvSequence("nij"), "ㄋㄞˋ");
  ASSERT_EQ(composer.cnvSequence("nad"), "ㄋㄟˊ");
  ASSERT_EQ(composer.cnvSequence("naf"), "ㄋㄟˇ");
  ASSERT_EQ(composer.cnvSequence("naj"), "ㄋㄟˋ");
  ASSERT_EQ(composer.cnvSequence("nw"), "ㄋㄠ");
  ASSERT_EQ(composer.cnvSequence("nwd"), "ㄋㄠˊ");
  ASSERT_EQ(composer.cnvSequence("nwf"), "ㄋㄠˇ");
  ASSERT_EQ(composer.cnvSequence("nwj"), "ㄋㄠˋ");
  ASSERT_EQ(composer.cnvSequence("nod"), "ㄋㄡˊ");
  ASSERT_EQ(composer.cnvSequence("nof"), "ㄋㄡˇ");
  ASSERT_EQ(composer.cnvSequence("noj"), "ㄋㄡˋ");
  ASSERT_EQ(composer.cnvSequence("nm"), "ㄋㄢ");
  ASSERT_EQ(composer.cnvSequence("nmd"), "ㄋㄢˊ");
  ASSERT_EQ(composer.cnvSequence("nmf"), "ㄋㄢˇ");
  ASSERT_EQ(composer.cnvSequence("nmj"), "ㄋㄢˋ");
  ASSERT_EQ(composer.cnvSequence("nnf"), "ㄋㄣˇ");
  ASSERT_EQ(composer.cnvSequence("nnj"), "ㄋㄣˋ");
  ASSERT_EQ(composer.cnvSequence("nk"), "ㄋㄤ");
  ASSERT_EQ(composer.cnvSequence("nkd"), "ㄋㄤˊ");
  ASSERT_EQ(composer.cnvSequence("nkf"), "ㄋㄤˇ");
  ASSERT_EQ(composer.cnvSequence("nkj"), "ㄋㄤˋ");
  ASSERT_EQ(composer.cnvSequence("nks"), "ㄋㄤ˙");
  ASSERT_EQ(composer.cnvSequence("nld"), "ㄋㄥˊ");
  ASSERT_EQ(composer.cnvSequence("nlf"), "ㄋㄥˇ");
  ASSERT_EQ(composer.cnvSequence("ne"), "ㄋㄧ");
  ASSERT_EQ(composer.cnvSequence("ned"), "ㄋㄧˊ");
  ASSERT_EQ(composer.cnvSequence("nef"), "ㄋㄧˇ");
  ASSERT_EQ(composer.cnvSequence("nej"), "ㄋㄧˋ");
  ASSERT_EQ(composer.cnvSequence("nee"), "ㄋㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("need"), "ㄋㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("neej"), "ㄋㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("newf"), "ㄋㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("newj"), "ㄋㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("neo"), "ㄋㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("neod"), "ㄋㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("neof"), "ㄋㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("neoj"), "ㄋㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("nem"), "ㄋㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("nemd"), "ㄋㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("nemf"), "ㄋㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("nemj"), "ㄋㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("nen"), "ㄋㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("nend"), "ㄋㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("nenf"), "ㄋㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("nenj"), "ㄋㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("nekd"), "ㄋㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("nekf"), "ㄋㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("nekj"), "ㄋㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("neld"), "ㄋㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("nelf"), "ㄋㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("nelj"), "ㄋㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("nxd"), "ㄋㄨˊ");
  ASSERT_EQ(composer.cnvSequence("nxf"), "ㄋㄨˇ");
  ASSERT_EQ(composer.cnvSequence("nxj"), "ㄋㄨˋ");
  ASSERT_EQ(composer.cnvSequence("nxhd"), "ㄋㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("nxhf"), "ㄋㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("nxhj"), "ㄋㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("nxad"), "ㄋㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("nxmd"), "ㄋㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("nxmf"), "ㄋㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("nxmj"), "ㄋㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("nxnd"), "ㄋㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("nxld"), "ㄋㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("nxlf"), "ㄋㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("nxlj"), "ㄋㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("nud"), "ㄋㄩˊ");
  ASSERT_EQ(composer.cnvSequence("nuf"), "ㄋㄩˇ");
  ASSERT_EQ(composer.cnvSequence("nuj"), "ㄋㄩˋ");
  ASSERT_EQ(composer.cnvSequence("nuej"), "ㄋㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("ly"), "ㄌㄚ");
  ASSERT_EQ(composer.cnvSequence("lyd"), "ㄌㄚˊ");
  ASSERT_EQ(composer.cnvSequence("lyf"), "ㄌㄚˇ");
  ASSERT_EQ(composer.cnvSequence("lyj"), "ㄌㄚˋ");
  ASSERT_EQ(composer.cnvSequence("lys"), "ㄌㄚ˙");
  ASSERT_EQ(composer.cnvSequence("lh"), "ㄌㄛ");
  ASSERT_EQ(composer.cnvSequence("lhs"), "ㄌㄛ˙");
  ASSERT_EQ(composer.cnvSequence("lg"), "ㄌㄜ");
  ASSERT_EQ(composer.cnvSequence("lgd"), "ㄌㄜˊ");
  ASSERT_EQ(composer.cnvSequence("lgj"), "ㄌㄜˋ");
  ASSERT_EQ(composer.cnvSequence("lgs"), "ㄌㄜ˙");
  ASSERT_EQ(composer.cnvSequence("lid"), "ㄌㄞˊ");
  ASSERT_EQ(composer.cnvSequence("lif"), "ㄌㄞˇ");
  ASSERT_EQ(composer.cnvSequence("lij"), "ㄌㄞˋ");
  ASSERT_EQ(composer.cnvSequence("la"), "ㄌㄟ");
  ASSERT_EQ(composer.cnvSequence("lad"), "ㄌㄟˊ");
  ASSERT_EQ(composer.cnvSequence("laf"), "ㄌㄟˇ");
  ASSERT_EQ(composer.cnvSequence("laj"), "ㄌㄟˋ");
  ASSERT_EQ(composer.cnvSequence("las"), "ㄌㄟ˙");
  ASSERT_EQ(composer.cnvSequence("lw"), "ㄌㄠ");
  ASSERT_EQ(composer.cnvSequence("lwd"), "ㄌㄠˊ");
  ASSERT_EQ(composer.cnvSequence("lwf"), "ㄌㄠˇ");
  ASSERT_EQ(composer.cnvSequence("lwj"), "ㄌㄠˋ");
  ASSERT_EQ(composer.cnvSequence("lo"), "ㄌㄡ");
  ASSERT_EQ(composer.cnvSequence("lod"), "ㄌㄡˊ");
  ASSERT_EQ(composer.cnvSequence("lof"), "ㄌㄡˇ");
  ASSERT_EQ(composer.cnvSequence("loj"), "ㄌㄡˋ");
  ASSERT_EQ(composer.cnvSequence("los"), "ㄌㄡ˙");
  ASSERT_EQ(composer.cnvSequence("lmd"), "ㄌㄢˊ");
  ASSERT_EQ(composer.cnvSequence("lmf"), "ㄌㄢˇ");
  ASSERT_EQ(composer.cnvSequence("lmj"), "ㄌㄢˋ");
  ASSERT_EQ(composer.cnvSequence("lk"), "ㄌㄤ");
  ASSERT_EQ(composer.cnvSequence("lkd"), "ㄌㄤˊ");
  ASSERT_EQ(composer.cnvSequence("lkf"), "ㄌㄤˇ");
  ASSERT_EQ(composer.cnvSequence("lkj"), "ㄌㄤˋ");
  ASSERT_EQ(composer.cnvSequence("ll"), "ㄌㄥ");
  ASSERT_EQ(composer.cnvSequence("lld"), "ㄌㄥˊ");
  ASSERT_EQ(composer.cnvSequence("llf"), "ㄌㄥˇ");
  ASSERT_EQ(composer.cnvSequence("llj"), "ㄌㄥˋ");
  ASSERT_EQ(composer.cnvSequence("le"), "ㄌㄧ");
  ASSERT_EQ(composer.cnvSequence("led"), "ㄌㄧˊ");
  ASSERT_EQ(composer.cnvSequence("lef"), "ㄌㄧˇ");
  ASSERT_EQ(composer.cnvSequence("lej"), "ㄌㄧˋ");
  ASSERT_EQ(composer.cnvSequence("les"), "ㄌㄧ˙");
  ASSERT_EQ(composer.cnvSequence("leyf"), "ㄌㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("lee"), "ㄌㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("leed"), "ㄌㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("leef"), "ㄌㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("leej"), "ㄌㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("lew"), "ㄌㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("lewd"), "ㄌㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("lewf"), "ㄌㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("lewj"), "ㄌㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("leo"), "ㄌㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("leod"), "ㄌㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("leof"), "ㄌㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("leoj"), "ㄌㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("lem"), "ㄌㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("lemd"), "ㄌㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("lemf"), "ㄌㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("lemj"), "ㄌㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("lend"), "ㄌㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("lenf"), "ㄌㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("lenj"), "ㄌㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("lekd"), "ㄌㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("lekf"), "ㄌㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("lekj"), "ㄌㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("lel"), "ㄌㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("leld"), "ㄌㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("lelf"), "ㄌㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("lelj"), "ㄌㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("lx"), "ㄌㄨ");
  ASSERT_EQ(composer.cnvSequence("lxd"), "ㄌㄨˊ");
  ASSERT_EQ(composer.cnvSequence("lxf"), "ㄌㄨˇ");
  ASSERT_EQ(composer.cnvSequence("lxj"), "ㄌㄨˋ");
  ASSERT_EQ(composer.cnvSequence("lxh"), "ㄌㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("lxhd"), "ㄌㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("lxhf"), "ㄌㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("lxhj"), "ㄌㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("lxhs"), "ㄌㄨㄛ˙");
  ASSERT_EQ(composer.cnvSequence("lxmd"), "ㄌㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("lxmf"), "ㄌㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("lxmj"), "ㄌㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("lxn"), "ㄌㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("lxnd"), "ㄌㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("lxnf"), "ㄌㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("lxnj"), "ㄌㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("lxl"), "ㄌㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("lxld"), "ㄌㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("lxlf"), "ㄌㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("lxlj"), "ㄌㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("lu"), "ㄌㄩ");
  ASSERT_EQ(composer.cnvSequence("lud"), "ㄌㄩˊ");
  ASSERT_EQ(composer.cnvSequence("luf"), "ㄌㄩˇ");
  ASSERT_EQ(composer.cnvSequence("luj"), "ㄌㄩˋ");
  ASSERT_EQ(composer.cnvSequence("lue"), "ㄌㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("luef"), "ㄌㄩㄝˇ");
  ASSERT_EQ(composer.cnvSequence("luej"), "ㄌㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("lumd"), "ㄌㄩㄢˊ");
  ASSERT_EQ(composer.cnvSequence("lumf"), "ㄌㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("gy"), "ㄍㄚ");
  ASSERT_EQ(composer.cnvSequence("gyd"), "ㄍㄚˊ");
  ASSERT_EQ(composer.cnvSequence("gyf"), "ㄍㄚˇ");
  ASSERT_EQ(composer.cnvSequence("gyj"), "ㄍㄚˋ");
  ASSERT_EQ(composer.cnvSequence("gys"), "ㄍㄚ˙");
  ASSERT_EQ(composer.cnvSequence("gg"), "ㄍㄜ");
  ASSERT_EQ(composer.cnvSequence("ggd"), "ㄍㄜˊ");
  ASSERT_EQ(composer.cnvSequence("ggf"), "ㄍㄜˇ");
  ASSERT_EQ(composer.cnvSequence("ggj"), "ㄍㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ggs"), "ㄍㄜ˙");
  ASSERT_EQ(composer.cnvSequence("gi"), "ㄍㄞ");
  ASSERT_EQ(composer.cnvSequence("gif"), "ㄍㄞˇ");
  ASSERT_EQ(composer.cnvSequence("gij"), "ㄍㄞˋ");
  ASSERT_EQ(composer.cnvSequence("gaf"), "ㄍㄟˇ");
  ASSERT_EQ(composer.cnvSequence("gw"), "ㄍㄠ");
  ASSERT_EQ(composer.cnvSequence("gwf"), "ㄍㄠˇ");
  ASSERT_EQ(composer.cnvSequence("gwj"), "ㄍㄠˋ");
  ASSERT_EQ(composer.cnvSequence("go"), "ㄍㄡ");
  ASSERT_EQ(composer.cnvSequence("gof"), "ㄍㄡˇ");
  ASSERT_EQ(composer.cnvSequence("goj"), "ㄍㄡˋ");
  ASSERT_EQ(composer.cnvSequence("gm"), "ㄍㄢ");
  ASSERT_EQ(composer.cnvSequence("gmf"), "ㄍㄢˇ");
  ASSERT_EQ(composer.cnvSequence("gmj"), "ㄍㄢˋ");
  ASSERT_EQ(composer.cnvSequence("gn"), "ㄍㄣ");
  ASSERT_EQ(composer.cnvSequence("gnd"), "ㄍㄣˊ");
  ASSERT_EQ(composer.cnvSequence("gnf"), "ㄍㄣˇ");
  ASSERT_EQ(composer.cnvSequence("gnj"), "ㄍㄣˋ");
  ASSERT_EQ(composer.cnvSequence("gk"), "ㄍㄤ");
  ASSERT_EQ(composer.cnvSequence("gkf"), "ㄍㄤˇ");
  ASSERT_EQ(composer.cnvSequence("gkj"), "ㄍㄤˋ");
  ASSERT_EQ(composer.cnvSequence("gl"), "ㄍㄥ");
  ASSERT_EQ(composer.cnvSequence("glf"), "ㄍㄥˇ");
  ASSERT_EQ(composer.cnvSequence("glj"), "ㄍㄥˋ");
  ASSERT_EQ(composer.cnvSequence("gx"), "ㄍㄨ");
  ASSERT_EQ(composer.cnvSequence("gxd"), "ㄍㄨˊ");
  ASSERT_EQ(composer.cnvSequence("gxf"), "ㄍㄨˇ");
  ASSERT_EQ(composer.cnvSequence("gxj"), "ㄍㄨˋ");
  ASSERT_EQ(composer.cnvSequence("gxy"), "ㄍㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("gxyd"), "ㄍㄨㄚˊ");
  ASSERT_EQ(composer.cnvSequence("gxyf"), "ㄍㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("gxyj"), "ㄍㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("gxh"), "ㄍㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("gxhd"), "ㄍㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("gxhf"), "ㄍㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("gxhj"), "ㄍㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("gxgd"), "ㄍㄨㄜˊ");
  ASSERT_EQ(composer.cnvSequence("gxi"), "ㄍㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("gxif"), "ㄍㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("gxij"), "ㄍㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("gxa"), "ㄍㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("gxaf"), "ㄍㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("gxaj"), "ㄍㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("gxm"), "ㄍㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("gxmf"), "ㄍㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("gxmj"), "ㄍㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("gxn"), "ㄍㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("gxnf"), "ㄍㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("gxnj"), "ㄍㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("gxk"), "ㄍㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("gxkf"), "ㄍㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("gxkj"), "ㄍㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("gxl"), "ㄍㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("gxld"), "ㄍㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("gxlf"), "ㄍㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("gxlj"), "ㄍㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ky"), "ㄎㄚ");
  ASSERT_EQ(composer.cnvSequence("kyf"), "ㄎㄚˇ");
  ASSERT_EQ(composer.cnvSequence("kyj"), "ㄎㄚˋ");
  ASSERT_EQ(composer.cnvSequence("kg"), "ㄎㄜ");
  ASSERT_EQ(composer.cnvSequence("kgd"), "ㄎㄜˊ");
  ASSERT_EQ(composer.cnvSequence("kgf"), "ㄎㄜˇ");
  ASSERT_EQ(composer.cnvSequence("kgj"), "ㄎㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ki"), "ㄎㄞ");
  ASSERT_EQ(composer.cnvSequence("kif"), "ㄎㄞˇ");
  ASSERT_EQ(composer.cnvSequence("kij"), "ㄎㄞˋ");
  ASSERT_EQ(composer.cnvSequence("kw"), "ㄎㄠ");
  ASSERT_EQ(composer.cnvSequence("kwf"), "ㄎㄠˇ");
  ASSERT_EQ(composer.cnvSequence("kwj"), "ㄎㄠˋ");
  ASSERT_EQ(composer.cnvSequence("ko"), "ㄎㄡ");
  ASSERT_EQ(composer.cnvSequence("kof"), "ㄎㄡˇ");
  ASSERT_EQ(composer.cnvSequence("koj"), "ㄎㄡˋ");
  ASSERT_EQ(composer.cnvSequence("km"), "ㄎㄢ");
  ASSERT_EQ(composer.cnvSequence("kmf"), "ㄎㄢˇ");
  ASSERT_EQ(composer.cnvSequence("kmj"), "ㄎㄢˋ");
  ASSERT_EQ(composer.cnvSequence("kn"), "ㄎㄣ");
  ASSERT_EQ(composer.cnvSequence("knf"), "ㄎㄣˇ");
  ASSERT_EQ(composer.cnvSequence("knj"), "ㄎㄣˋ");
  ASSERT_EQ(composer.cnvSequence("kk"), "ㄎㄤ");
  ASSERT_EQ(composer.cnvSequence("kkd"), "ㄎㄤˊ");
  ASSERT_EQ(composer.cnvSequence("kkf"), "ㄎㄤˇ");
  ASSERT_EQ(composer.cnvSequence("kkj"), "ㄎㄤˋ");
  ASSERT_EQ(composer.cnvSequence("kl"), "ㄎㄥ");
  ASSERT_EQ(composer.cnvSequence("klf"), "ㄎㄥˇ");
  ASSERT_EQ(composer.cnvSequence("kx"), "ㄎㄨ");
  ASSERT_EQ(composer.cnvSequence("kxd"), "ㄎㄨˊ");
  ASSERT_EQ(composer.cnvSequence("kxf"), "ㄎㄨˇ");
  ASSERT_EQ(composer.cnvSequence("kxj"), "ㄎㄨˋ");
  ASSERT_EQ(composer.cnvSequence("kxy"), "ㄎㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("kxyf"), "ㄎㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("kxyj"), "ㄎㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("kxhj"), "ㄎㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("kxi"), "ㄎㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("kxif"), "ㄎㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("kxij"), "ㄎㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("kxa"), "ㄎㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("kxad"), "ㄎㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("kxaf"), "ㄎㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("kxaj"), "ㄎㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("kxm"), "ㄎㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("kxmf"), "ㄎㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("kxmj"), "ㄎㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("kxn"), "ㄎㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("kxnf"), "ㄎㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("kxnj"), "ㄎㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("kxk"), "ㄎㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("kxkd"), "ㄎㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("kxkf"), "ㄎㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("kxkj"), "ㄎㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("kxl"), "ㄎㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("kxlf"), "ㄎㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("kxlj"), "ㄎㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("hy"), "ㄏㄚ");
  ASSERT_EQ(composer.cnvSequence("hyd"), "ㄏㄚˊ");
  ASSERT_EQ(composer.cnvSequence("hyf"), "ㄏㄚˇ");
  ASSERT_EQ(composer.cnvSequence("hg"), "ㄏㄜ");
  ASSERT_EQ(composer.cnvSequence("hgd"), "ㄏㄜˊ");
  ASSERT_EQ(composer.cnvSequence("hgf"), "ㄏㄜˇ");
  ASSERT_EQ(composer.cnvSequence("hgj"), "ㄏㄜˋ");
  ASSERT_EQ(composer.cnvSequence("hi"), "ㄏㄞ");
  ASSERT_EQ(composer.cnvSequence("hid"), "ㄏㄞˊ");
  ASSERT_EQ(composer.cnvSequence("hif"), "ㄏㄞˇ");
  ASSERT_EQ(composer.cnvSequence("hij"), "ㄏㄞˋ");
  ASSERT_EQ(composer.cnvSequence("ha"), "ㄏㄟ");
  ASSERT_EQ(composer.cnvSequence("haf"), "ㄏㄟˇ");
  ASSERT_EQ(composer.cnvSequence("hw"), "ㄏㄠ");
  ASSERT_EQ(composer.cnvSequence("hwd"), "ㄏㄠˊ");
  ASSERT_EQ(composer.cnvSequence("hwf"), "ㄏㄠˇ");
  ASSERT_EQ(composer.cnvSequence("hwj"), "ㄏㄠˋ");
  ASSERT_EQ(composer.cnvSequence("ho"), "ㄏㄡ");
  ASSERT_EQ(composer.cnvSequence("hod"), "ㄏㄡˊ");
  ASSERT_EQ(composer.cnvSequence("hof"), "ㄏㄡˇ");
  ASSERT_EQ(composer.cnvSequence("hoj"), "ㄏㄡˋ");
  ASSERT_EQ(composer.cnvSequence("hm"), "ㄏㄢ");
  ASSERT_EQ(composer.cnvSequence("hmd"), "ㄏㄢˊ");
  ASSERT_EQ(composer.cnvSequence("hmf"), "ㄏㄢˇ");
  ASSERT_EQ(composer.cnvSequence("hmj"), "ㄏㄢˋ");
  ASSERT_EQ(composer.cnvSequence("hn"), "ㄏㄣ");
  ASSERT_EQ(composer.cnvSequence("hnd"), "ㄏㄣˊ");
  ASSERT_EQ(composer.cnvSequence("hnf"), "ㄏㄣˇ");
  ASSERT_EQ(composer.cnvSequence("hnj"), "ㄏㄣˋ");
  ASSERT_EQ(composer.cnvSequence("hk"), "ㄏㄤ");
  ASSERT_EQ(composer.cnvSequence("hkd"), "ㄏㄤˊ");
  ASSERT_EQ(composer.cnvSequence("hkf"), "ㄏㄤˇ");
  ASSERT_EQ(composer.cnvSequence("hkj"), "ㄏㄤˋ");
  ASSERT_EQ(composer.cnvSequence("hl"), "ㄏㄥ");
  ASSERT_EQ(composer.cnvSequence("hld"), "ㄏㄥˊ");
  ASSERT_EQ(composer.cnvSequence("hlj"), "ㄏㄥˋ");
  ASSERT_EQ(composer.cnvSequence("hx"), "ㄏㄨ");
  ASSERT_EQ(composer.cnvSequence("hxd"), "ㄏㄨˊ");
  ASSERT_EQ(composer.cnvSequence("hxf"), "ㄏㄨˇ");
  ASSERT_EQ(composer.cnvSequence("hxj"), "ㄏㄨˋ");
  ASSERT_EQ(composer.cnvSequence("hxy"), "ㄏㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("hxyd"), "ㄏㄨㄚˊ");
  ASSERT_EQ(composer.cnvSequence("hxyf"), "ㄏㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("hxyj"), "ㄏㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("hxh"), "ㄏㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("hxhd"), "ㄏㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("hxhf"), "ㄏㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("hxhj"), "ㄏㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("hxhs"), "ㄏㄨㄛ˙");
  ASSERT_EQ(composer.cnvSequence("hxid"), "ㄏㄨㄞˊ");
  ASSERT_EQ(composer.cnvSequence("hxij"), "ㄏㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("hxa"), "ㄏㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("hxad"), "ㄏㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("hxaf"), "ㄏㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("hxaj"), "ㄏㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("hxm"), "ㄏㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("hxmd"), "ㄏㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("hxmf"), "ㄏㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("hxmj"), "ㄏㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("hxn"), "ㄏㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("hxnd"), "ㄏㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("hxnf"), "ㄏㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("hxnj"), "ㄏㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("hxk"), "ㄏㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("hxkd"), "ㄏㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("hxkf"), "ㄏㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("hxkj"), "ㄏㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("hxks"), "ㄏㄨㄤ˙");
  ASSERT_EQ(composer.cnvSequence("hxl"), "ㄏㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("hxld"), "ㄏㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("hxlf"), "ㄏㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("hxlj"), "ㄏㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("je"), "ㄐㄧ");
  ASSERT_EQ(composer.cnvSequence("jed"), "ㄐㄧˊ");
  ASSERT_EQ(composer.cnvSequence("jef"), "ㄐㄧˇ");
  ASSERT_EQ(composer.cnvSequence("jej"), "ㄐㄧˋ");
  ASSERT_EQ(composer.cnvSequence("jey"), "ㄐㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("jeyd"), "ㄐㄧㄚˊ");
  ASSERT_EQ(composer.cnvSequence("jeyf"), "ㄐㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("jeyj"), "ㄐㄧㄚˋ");
  ASSERT_EQ(composer.cnvSequence("jee"), "ㄐㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("jeed"), "ㄐㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("jeef"), "ㄐㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("jeej"), "ㄐㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("jees"), "ㄐㄧㄝ˙");
  ASSERT_EQ(composer.cnvSequence("jew"), "ㄐㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("jewd"), "ㄐㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("jewf"), "ㄐㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("jewj"), "ㄐㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("jeo"), "ㄐㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("jeof"), "ㄐㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("jeoj"), "ㄐㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("jem"), "ㄐㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("jemf"), "ㄐㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("jemj"), "ㄐㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("jen"), "ㄐㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("jenf"), "ㄐㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("jenj"), "ㄐㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("jek"), "ㄐㄧㄤ");
  ASSERT_EQ(composer.cnvSequence("jekd"), "ㄐㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("jekf"), "ㄐㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("jekj"), "ㄐㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("jel"), "ㄐㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("jelf"), "ㄐㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("jelj"), "ㄐㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ju"), "ㄐㄩ");
  ASSERT_EQ(composer.cnvSequence("jud"), "ㄐㄩˊ");
  ASSERT_EQ(composer.cnvSequence("juf"), "ㄐㄩˇ");
  ASSERT_EQ(composer.cnvSequence("juj"), "ㄐㄩˋ");
  ASSERT_EQ(composer.cnvSequence("jue"), "ㄐㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("jued"), "ㄐㄩㄝˊ");
  ASSERT_EQ(composer.cnvSequence("juef"), "ㄐㄩㄝˇ");
  ASSERT_EQ(composer.cnvSequence("juej"), "ㄐㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("jum"), "ㄐㄩㄢ");
  ASSERT_EQ(composer.cnvSequence("jumf"), "ㄐㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("jumj"), "ㄐㄩㄢˋ");
  ASSERT_EQ(composer.cnvSequence("jun"), "ㄐㄩㄣ");
  ASSERT_EQ(composer.cnvSequence("jund"), "ㄐㄩㄣˊ");
  ASSERT_EQ(composer.cnvSequence("junf"), "ㄐㄩㄣˇ");
  ASSERT_EQ(composer.cnvSequence("junj"), "ㄐㄩㄣˋ");
  ASSERT_EQ(composer.cnvSequence("jul"), "ㄐㄩㄥ");
  ASSERT_EQ(composer.cnvSequence("julf"), "ㄐㄩㄥˇ");
  ASSERT_EQ(composer.cnvSequence("julj"), "ㄐㄩㄥˋ");
  // ASSERT_EQ(composer.cnvSequence("vs"), "ㄑ˙");
  ASSERT_EQ(composer.cnvSequence("ve"), "ㄑㄧ");
  ASSERT_EQ(composer.cnvSequence("ved"), "ㄑㄧˊ");
  ASSERT_EQ(composer.cnvSequence("vef"), "ㄑㄧˇ");
  ASSERT_EQ(composer.cnvSequence("vej"), "ㄑㄧˋ");
  ASSERT_EQ(composer.cnvSequence("vey"), "ㄑㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("veyd"), "ㄑㄧㄚˊ");
  ASSERT_EQ(composer.cnvSequence("veyf"), "ㄑㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("veyj"), "ㄑㄧㄚˋ");
  ASSERT_EQ(composer.cnvSequence("vee"), "ㄑㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("veed"), "ㄑㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("veef"), "ㄑㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("veej"), "ㄑㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("vew"), "ㄑㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("vewd"), "ㄑㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("vewf"), "ㄑㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("vewj"), "ㄑㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("veo"), "ㄑㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("veod"), "ㄑㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("veof"), "ㄑㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("veoj"), "ㄑㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("vem"), "ㄑㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("vemd"), "ㄑㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("vemf"), "ㄑㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("vemj"), "ㄑㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("ven"), "ㄑㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("vend"), "ㄑㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("venf"), "ㄑㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("venj"), "ㄑㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("vek"), "ㄑㄧㄤ");
  ASSERT_EQ(composer.cnvSequence("vekd"), "ㄑㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("vekf"), "ㄑㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("vekj"), "ㄑㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("vel"), "ㄑㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("veld"), "ㄑㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("velf"), "ㄑㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("velj"), "ㄑㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("vu"), "ㄑㄩ");
  ASSERT_EQ(composer.cnvSequence("vud"), "ㄑㄩˊ");
  ASSERT_EQ(composer.cnvSequence("vuf"), "ㄑㄩˇ");
  ASSERT_EQ(composer.cnvSequence("vuj"), "ㄑㄩˋ");
  ASSERT_EQ(composer.cnvSequence("vue"), "ㄑㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("vued"), "ㄑㄩㄝˊ");
  ASSERT_EQ(composer.cnvSequence("vuej"), "ㄑㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("vum"), "ㄑㄩㄢ");
  ASSERT_EQ(composer.cnvSequence("vumd"), "ㄑㄩㄢˊ");
  ASSERT_EQ(composer.cnvSequence("vumf"), "ㄑㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("vumj"), "ㄑㄩㄢˋ");
  ASSERT_EQ(composer.cnvSequence("vun"), "ㄑㄩㄣ");
  ASSERT_EQ(composer.cnvSequence("vund"), "ㄑㄩㄣˊ");
  ASSERT_EQ(composer.cnvSequence("vunf"), "ㄑㄩㄣˇ");
  ASSERT_EQ(composer.cnvSequence("vunj"), "ㄑㄩㄣˋ");
  ASSERT_EQ(composer.cnvSequence("vul"), "ㄑㄩㄥ");
  ASSERT_EQ(composer.cnvSequence("vuld"), "ㄑㄩㄥˊ");
  ASSERT_EQ(composer.cnvSequence("vulf"), "ㄑㄩㄥˇ");
  ASSERT_EQ(composer.cnvSequence("vulj"), "ㄑㄩㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ce"), "ㄒㄧ");
  ASSERT_EQ(composer.cnvSequence("ced"), "ㄒㄧˊ");
  ASSERT_EQ(composer.cnvSequence("cef"), "ㄒㄧˇ");
  ASSERT_EQ(composer.cnvSequence("cej"), "ㄒㄧˋ");
  ASSERT_EQ(composer.cnvSequence("cey"), "ㄒㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("ceyd"), "ㄒㄧㄚˊ");
  ASSERT_EQ(composer.cnvSequence("ceyf"), "ㄒㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("ceyj"), "ㄒㄧㄚˋ");
  ASSERT_EQ(composer.cnvSequence("cee"), "ㄒㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("ceed"), "ㄒㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("ceef"), "ㄒㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("ceej"), "ㄒㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("cew"), "ㄒㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("cewd"), "ㄒㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("cewf"), "ㄒㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("cewj"), "ㄒㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("ceo"), "ㄒㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("ceod"), "ㄒㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("ceof"), "ㄒㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("ceoj"), "ㄒㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("cem"), "ㄒㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("cemd"), "ㄒㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("cemf"), "ㄒㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("cemj"), "ㄒㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("cen"), "ㄒㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("cend"), "ㄒㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("cenf"), "ㄒㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("cenj"), "ㄒㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("cek"), "ㄒㄧㄤ");
  ASSERT_EQ(composer.cnvSequence("cekd"), "ㄒㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("cekf"), "ㄒㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("cekj"), "ㄒㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("cel"), "ㄒㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("celd"), "ㄒㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("celf"), "ㄒㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("celj"), "ㄒㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("cu"), "ㄒㄩ");
  ASSERT_EQ(composer.cnvSequence("cud"), "ㄒㄩˊ");
  ASSERT_EQ(composer.cnvSequence("cuf"), "ㄒㄩˇ");
  ASSERT_EQ(composer.cnvSequence("cuj"), "ㄒㄩˋ");
  ASSERT_EQ(composer.cnvSequence("cue"), "ㄒㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("cued"), "ㄒㄩㄝˊ");
  ASSERT_EQ(composer.cnvSequence("cuef"), "ㄒㄩㄝˇ");
  ASSERT_EQ(composer.cnvSequence("cuej"), "ㄒㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("cum"), "ㄒㄩㄢ");
  ASSERT_EQ(composer.cnvSequence("cumd"), "ㄒㄩㄢˊ");
  ASSERT_EQ(composer.cnvSequence("cumf"), "ㄒㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("cumj"), "ㄒㄩㄢˋ");
  ASSERT_EQ(composer.cnvSequence("cun"), "ㄒㄩㄣ");
  ASSERT_EQ(composer.cnvSequence("cund"), "ㄒㄩㄣˊ");
  ASSERT_EQ(composer.cnvSequence("cunj"), "ㄒㄩㄣˋ");
  ASSERT_EQ(composer.cnvSequence("cul"), "ㄒㄩㄥ");
  ASSERT_EQ(composer.cnvSequence("culd"), "ㄒㄩㄥˊ");
  ASSERT_EQ(composer.cnvSequence("culf"), "ㄒㄩㄥˇ");
  ASSERT_EQ(composer.cnvSequence("culj"), "ㄒㄩㄥˋ");
  ASSERT_EQ(composer.cnvSequence("j"), "ㄓ");
  ASSERT_EQ(composer.cnvSequence("jd"), "ㄓˊ");
  ASSERT_EQ(composer.cnvSequence("jf"), "ㄓˇ");
  ASSERT_EQ(composer.cnvSequence("jj"), "ㄓˋ");
  ASSERT_EQ(composer.cnvSequence("jy"), "ㄓㄚ");
  ASSERT_EQ(composer.cnvSequence("jyd"), "ㄓㄚˊ");
  ASSERT_EQ(composer.cnvSequence("jyf"), "ㄓㄚˇ");
  ASSERT_EQ(composer.cnvSequence("jyj"), "ㄓㄚˋ");
  ASSERT_EQ(composer.cnvSequence("jg"), "ㄓㄜ");
  ASSERT_EQ(composer.cnvSequence("jgd"), "ㄓㄜˊ");
  ASSERT_EQ(composer.cnvSequence("jgf"), "ㄓㄜˇ");
  ASSERT_EQ(composer.cnvSequence("jgj"), "ㄓㄜˋ");
  ASSERT_EQ(composer.cnvSequence("jgs"), "ㄓㄜ˙");
  ASSERT_EQ(composer.cnvSequence("ji"), "ㄓㄞ");
  ASSERT_EQ(composer.cnvSequence("jid"), "ㄓㄞˊ");
  ASSERT_EQ(composer.cnvSequence("jif"), "ㄓㄞˇ");
  ASSERT_EQ(composer.cnvSequence("jij"), "ㄓㄞˋ");
  ASSERT_EQ(composer.cnvSequence("jaj"), "ㄓㄟˋ");
  ASSERT_EQ(composer.cnvSequence("jw"), "ㄓㄠ");
  ASSERT_EQ(composer.cnvSequence("jwd"), "ㄓㄠˊ");
  ASSERT_EQ(composer.cnvSequence("jwf"), "ㄓㄠˇ");
  ASSERT_EQ(composer.cnvSequence("jwj"), "ㄓㄠˋ");
  ASSERT_EQ(composer.cnvSequence("jo"), "ㄓㄡ");
  ASSERT_EQ(composer.cnvSequence("jod"), "ㄓㄡˊ");
  ASSERT_EQ(composer.cnvSequence("jof"), "ㄓㄡˇ");
  ASSERT_EQ(composer.cnvSequence("joj"), "ㄓㄡˋ");
  ASSERT_EQ(composer.cnvSequence("jm"), "ㄓㄢ");
  ASSERT_EQ(composer.cnvSequence("jmf"), "ㄓㄢˇ");
  ASSERT_EQ(composer.cnvSequence("jmj"), "ㄓㄢˋ");
  ASSERT_EQ(composer.cnvSequence("jn"), "ㄓㄣ");
  ASSERT_EQ(composer.cnvSequence("jnd"), "ㄓㄣˊ");
  ASSERT_EQ(composer.cnvSequence("jnf"), "ㄓㄣˇ");
  ASSERT_EQ(composer.cnvSequence("jnj"), "ㄓㄣˋ");
  ASSERT_EQ(composer.cnvSequence("jk"), "ㄓㄤ");
  ASSERT_EQ(composer.cnvSequence("jkf"), "ㄓㄤˇ");
  ASSERT_EQ(composer.cnvSequence("jkj"), "ㄓㄤˋ");
  ASSERT_EQ(composer.cnvSequence("jl"), "ㄓㄥ");
  ASSERT_EQ(composer.cnvSequence("jlf"), "ㄓㄥˇ");
  ASSERT_EQ(composer.cnvSequence("jlj"), "ㄓㄥˋ");
  ASSERT_EQ(composer.cnvSequence("jx"), "ㄓㄨ");
  ASSERT_EQ(composer.cnvSequence("jxd"), "ㄓㄨˊ");
  ASSERT_EQ(composer.cnvSequence("jxf"), "ㄓㄨˇ");
  ASSERT_EQ(composer.cnvSequence("jxj"), "ㄓㄨˋ");
  ASSERT_EQ(composer.cnvSequence("jxy"), "ㄓㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("jxyf"), "ㄓㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("jxh"), "ㄓㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("jxhd"), "ㄓㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("jxhj"), "ㄓㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("jxi"), "ㄓㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("jxif"), "ㄓㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("jxij"), "ㄓㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("jxa"), "ㄓㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("jxaf"), "ㄓㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("jxaj"), "ㄓㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("jxm"), "ㄓㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("jxmf"), "ㄓㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("jxmj"), "ㄓㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("jxn"), "ㄓㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("jxnf"), "ㄓㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("jxnj"), "ㄓㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("jxk"), "ㄓㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("jxkf"), "ㄓㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("jxkj"), "ㄓㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("jxl"), "ㄓㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("jxlf"), "ㄓㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("jxlj"), "ㄓㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("v"), "ㄔ");
  ASSERT_EQ(composer.cnvSequence("vd"), "ㄔˊ");
  ASSERT_EQ(composer.cnvSequence("vf"), "ㄔˇ");
  ASSERT_EQ(composer.cnvSequence("vj"), "ㄔˋ");
  ASSERT_EQ(composer.cnvSequence("vy"), "ㄔㄚ");
  ASSERT_EQ(composer.cnvSequence("vyd"), "ㄔㄚˊ");
  ASSERT_EQ(composer.cnvSequence("vyf"), "ㄔㄚˇ");
  ASSERT_EQ(composer.cnvSequence("vyj"), "ㄔㄚˋ");
  ASSERT_EQ(composer.cnvSequence("vg"), "ㄔㄜ");
  ASSERT_EQ(composer.cnvSequence("vgf"), "ㄔㄜˇ");
  ASSERT_EQ(composer.cnvSequence("vgj"), "ㄔㄜˋ");
  ASSERT_EQ(composer.cnvSequence("vi"), "ㄔㄞ");
  ASSERT_EQ(composer.cnvSequence("vid"), "ㄔㄞˊ");
  ASSERT_EQ(composer.cnvSequence("vif"), "ㄔㄞˇ");
  ASSERT_EQ(composer.cnvSequence("vij"), "ㄔㄞˋ");
  ASSERT_EQ(composer.cnvSequence("vw"), "ㄔㄠ");
  ASSERT_EQ(composer.cnvSequence("vwd"), "ㄔㄠˊ");
  ASSERT_EQ(composer.cnvSequence("vwf"), "ㄔㄠˇ");
  ASSERT_EQ(composer.cnvSequence("vwj"), "ㄔㄠˋ");
  ASSERT_EQ(composer.cnvSequence("vo"), "ㄔㄡ");
  ASSERT_EQ(composer.cnvSequence("vod"), "ㄔㄡˊ");
  ASSERT_EQ(composer.cnvSequence("vof"), "ㄔㄡˇ");
  ASSERT_EQ(composer.cnvSequence("voj"), "ㄔㄡˋ");
  ASSERT_EQ(composer.cnvSequence("vm"), "ㄔㄢ");
  ASSERT_EQ(composer.cnvSequence("vmd"), "ㄔㄢˊ");
  ASSERT_EQ(composer.cnvSequence("vmf"), "ㄔㄢˇ");
  ASSERT_EQ(composer.cnvSequence("vmj"), "ㄔㄢˋ");
  ASSERT_EQ(composer.cnvSequence("vn"), "ㄔㄣ");
  ASSERT_EQ(composer.cnvSequence("vnd"), "ㄔㄣˊ");
  ASSERT_EQ(composer.cnvSequence("vnf"), "ㄔㄣˇ");
  ASSERT_EQ(composer.cnvSequence("vnj"), "ㄔㄣˋ");
  ASSERT_EQ(composer.cnvSequence("vns"), "ㄔㄣ˙");
  ASSERT_EQ(composer.cnvSequence("vk"), "ㄔㄤ");
  ASSERT_EQ(composer.cnvSequence("vkd"), "ㄔㄤˊ");
  ASSERT_EQ(composer.cnvSequence("vkf"), "ㄔㄤˇ");
  ASSERT_EQ(composer.cnvSequence("vkj"), "ㄔㄤˋ");
  ASSERT_EQ(composer.cnvSequence("vl"), "ㄔㄥ");
  ASSERT_EQ(composer.cnvSequence("vld"), "ㄔㄥˊ");
  ASSERT_EQ(composer.cnvSequence("vlf"), "ㄔㄥˇ");
  ASSERT_EQ(composer.cnvSequence("vlj"), "ㄔㄥˋ");
  ASSERT_EQ(composer.cnvSequence("vx"), "ㄔㄨ");
  ASSERT_EQ(composer.cnvSequence("vxd"), "ㄔㄨˊ");
  ASSERT_EQ(composer.cnvSequence("vxf"), "ㄔㄨˇ");
  ASSERT_EQ(composer.cnvSequence("vxj"), "ㄔㄨˋ");
  ASSERT_EQ(composer.cnvSequence("vxy"), "ㄔㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("vxyf"), "ㄔㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("vxyj"), "ㄔㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("vxh"), "ㄔㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("vxhj"), "ㄔㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("vxi"), "ㄔㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("vxid"), "ㄔㄨㄞˊ");
  ASSERT_EQ(composer.cnvSequence("vxif"), "ㄔㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("vxij"), "ㄔㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("vxa"), "ㄔㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("vxad"), "ㄔㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("vxaf"), "ㄔㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("vxaj"), "ㄔㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("vxm"), "ㄔㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("vxmd"), "ㄔㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("vxmf"), "ㄔㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("vxmj"), "ㄔㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("vxn"), "ㄔㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("vxnd"), "ㄔㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("vxnf"), "ㄔㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("vxk"), "ㄔㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("vxkd"), "ㄔㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("vxkf"), "ㄔㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("vxkj"), "ㄔㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("vxl"), "ㄔㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("vxld"), "ㄔㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("vxlf"), "ㄔㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("vxlj"), "ㄔㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("c"), "ㄕ");
  ASSERT_EQ(composer.cnvSequence("cd"), "ㄕˊ");
  ASSERT_EQ(composer.cnvSequence("cf"), "ㄕˇ");
  ASSERT_EQ(composer.cnvSequence("cj"), "ㄕˋ");
  ASSERT_EQ(composer.cnvSequence("cs"), "ㄕ˙");
  ASSERT_EQ(composer.cnvSequence("cy"), "ㄕㄚ");
  ASSERT_EQ(composer.cnvSequence("cyd"), "ㄕㄚˊ");
  ASSERT_EQ(composer.cnvSequence("cyf"), "ㄕㄚˇ");
  ASSERT_EQ(composer.cnvSequence("cyj"), "ㄕㄚˋ");
  ASSERT_EQ(composer.cnvSequence("cys"), "ㄕㄚ˙");
  ASSERT_EQ(composer.cnvSequence("cg"), "ㄕㄜ");
  ASSERT_EQ(composer.cnvSequence("cgd"), "ㄕㄜˊ");
  ASSERT_EQ(composer.cnvSequence("cgf"), "ㄕㄜˇ");
  ASSERT_EQ(composer.cnvSequence("cgj"), "ㄕㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ci"), "ㄕㄞ");
  ASSERT_EQ(composer.cnvSequence("cif"), "ㄕㄞˇ");
  ASSERT_EQ(composer.cnvSequence("cij"), "ㄕㄞˋ");
  ASSERT_EQ(composer.cnvSequence("cad"), "ㄕㄟˊ");
  ASSERT_EQ(composer.cnvSequence("cw"), "ㄕㄠ");
  ASSERT_EQ(composer.cnvSequence("cwd"), "ㄕㄠˊ");
  ASSERT_EQ(composer.cnvSequence("cwf"), "ㄕㄠˇ");
  ASSERT_EQ(composer.cnvSequence("cwj"), "ㄕㄠˋ");
  ASSERT_EQ(composer.cnvSequence("co"), "ㄕㄡ");
  ASSERT_EQ(composer.cnvSequence("cod"), "ㄕㄡˊ");
  ASSERT_EQ(composer.cnvSequence("cof"), "ㄕㄡˇ");
  ASSERT_EQ(composer.cnvSequence("coj"), "ㄕㄡˋ");
  ASSERT_EQ(composer.cnvSequence("cm"), "ㄕㄢ");
  ASSERT_EQ(composer.cnvSequence("cmd"), "ㄕㄢˊ");
  ASSERT_EQ(composer.cnvSequence("cmf"), "ㄕㄢˇ");
  ASSERT_EQ(composer.cnvSequence("cmj"), "ㄕㄢˋ");
  ASSERT_EQ(composer.cnvSequence("cn"), "ㄕㄣ");
  ASSERT_EQ(composer.cnvSequence("cnd"), "ㄕㄣˊ");
  ASSERT_EQ(composer.cnvSequence("cnf"), "ㄕㄣˇ");
  ASSERT_EQ(composer.cnvSequence("cnj"), "ㄕㄣˋ");
  ASSERT_EQ(composer.cnvSequence("ck"), "ㄕㄤ");
  ASSERT_EQ(composer.cnvSequence("ckf"), "ㄕㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ckj"), "ㄕㄤˋ");
  ASSERT_EQ(composer.cnvSequence("cks"), "ㄕㄤ˙");
  ASSERT_EQ(composer.cnvSequence("cl"), "ㄕㄥ");
  ASSERT_EQ(composer.cnvSequence("cld"), "ㄕㄥˊ");
  ASSERT_EQ(composer.cnvSequence("clf"), "ㄕㄥˇ");
  ASSERT_EQ(composer.cnvSequence("clj"), "ㄕㄥˋ");
  ASSERT_EQ(composer.cnvSequence("cx"), "ㄕㄨ");
  ASSERT_EQ(composer.cnvSequence("cxd"), "ㄕㄨˊ");
  ASSERT_EQ(composer.cnvSequence("cxf"), "ㄕㄨˇ");
  ASSERT_EQ(composer.cnvSequence("cxj"), "ㄕㄨˋ");
  ASSERT_EQ(composer.cnvSequence("cxy"), "ㄕㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("cxyf"), "ㄕㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("cxyj"), "ㄕㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("cxh"), "ㄕㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("cxhj"), "ㄕㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("cxi"), "ㄕㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("cxif"), "ㄕㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("cxij"), "ㄕㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("cxa"), "ㄕㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("cxad"), "ㄕㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("cxaf"), "ㄕㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("cxaj"), "ㄕㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("cxm"), "ㄕㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("cxmj"), "ㄕㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("cxnf"), "ㄕㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("cxnj"), "ㄕㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("cxk"), "ㄕㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("cxkd"), "ㄕㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("cxkf"), "ㄕㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("cxkj"), "ㄕㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("rj"), "ㄖˋ");
  ASSERT_EQ(composer.cnvSequence("rgf"), "ㄖㄜˇ");
  ASSERT_EQ(composer.cnvSequence("rgj"), "ㄖㄜˋ");
  ASSERT_EQ(composer.cnvSequence("rwd"), "ㄖㄠˊ");
  ASSERT_EQ(composer.cnvSequence("rwf"), "ㄖㄠˇ");
  ASSERT_EQ(composer.cnvSequence("rwj"), "ㄖㄠˋ");
  ASSERT_EQ(composer.cnvSequence("rod"), "ㄖㄡˊ");
  ASSERT_EQ(composer.cnvSequence("rof"), "ㄖㄡˇ");
  ASSERT_EQ(composer.cnvSequence("roj"), "ㄖㄡˋ");
  ASSERT_EQ(composer.cnvSequence("rmd"), "ㄖㄢˊ");
  ASSERT_EQ(composer.cnvSequence("rmf"), "ㄖㄢˇ");
  ASSERT_EQ(composer.cnvSequence("rmj"), "ㄖㄢˋ");
  ASSERT_EQ(composer.cnvSequence("rnd"), "ㄖㄣˊ");
  ASSERT_EQ(composer.cnvSequence("rnf"), "ㄖㄣˇ");
  ASSERT_EQ(composer.cnvSequence("rnj"), "ㄖㄣˋ");
  ASSERT_EQ(composer.cnvSequence("rk"), "ㄖㄤ");
  ASSERT_EQ(composer.cnvSequence("rkd"), "ㄖㄤˊ");
  ASSERT_EQ(composer.cnvSequence("rkf"), "ㄖㄤˇ");
  ASSERT_EQ(composer.cnvSequence("rkj"), "ㄖㄤˋ");
  ASSERT_EQ(composer.cnvSequence("rl"), "ㄖㄥ");
  ASSERT_EQ(composer.cnvSequence("rld"), "ㄖㄥˊ");
  ASSERT_EQ(composer.cnvSequence("rlf"), "ㄖㄥˇ");
  ASSERT_EQ(composer.cnvSequence("rlj"), "ㄖㄥˋ");
  ASSERT_EQ(composer.cnvSequence("rxd"), "ㄖㄨˊ");
  ASSERT_EQ(composer.cnvSequence("rxf"), "ㄖㄨˇ");
  ASSERT_EQ(composer.cnvSequence("rxj"), "ㄖㄨˋ");
  ASSERT_EQ(composer.cnvSequence("rxhd"), "ㄖㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("rxhj"), "ㄖㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("rxad"), "ㄖㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("rxaf"), "ㄖㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("rxaj"), "ㄖㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("rxmd"), "ㄖㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("rxmf"), "ㄖㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("rxmj"), "ㄖㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("rxnd"), "ㄖㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("rxnf"), "ㄖㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("rxnj"), "ㄖㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("rxld"), "ㄖㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("rxlf"), "ㄖㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("rxlj"), "ㄖㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("z"), "ㄗ");
  ASSERT_EQ(composer.cnvSequence("zd"), "ㄗˊ");
  ASSERT_EQ(composer.cnvSequence("zf"), "ㄗˇ");
  ASSERT_EQ(composer.cnvSequence("zj"), "ㄗˋ");
  ASSERT_EQ(composer.cnvSequence("zs"), "ㄗ˙");
  ASSERT_EQ(composer.cnvSequence("zy"), "ㄗㄚ");
  ASSERT_EQ(composer.cnvSequence("zyd"), "ㄗㄚˊ");
  ASSERT_EQ(composer.cnvSequence("zyf"), "ㄗㄚˇ");
  ASSERT_EQ(composer.cnvSequence("zgd"), "ㄗㄜˊ");
  ASSERT_EQ(composer.cnvSequence("zgf"), "ㄗㄜˇ");
  ASSERT_EQ(composer.cnvSequence("zgj"), "ㄗㄜˋ");
  ASSERT_EQ(composer.cnvSequence("zi"), "ㄗㄞ");
  ASSERT_EQ(composer.cnvSequence("zif"), "ㄗㄞˇ");
  ASSERT_EQ(composer.cnvSequence("zij"), "ㄗㄞˋ");
  ASSERT_EQ(composer.cnvSequence("zad"), "ㄗㄟˊ");
  ASSERT_EQ(composer.cnvSequence("zw"), "ㄗㄠ");
  ASSERT_EQ(composer.cnvSequence("zwd"), "ㄗㄠˊ");
  ASSERT_EQ(composer.cnvSequence("zwf"), "ㄗㄠˇ");
  ASSERT_EQ(composer.cnvSequence("zwj"), "ㄗㄠˋ");
  ASSERT_EQ(composer.cnvSequence("zo"), "ㄗㄡ");
  ASSERT_EQ(composer.cnvSequence("zof"), "ㄗㄡˇ");
  ASSERT_EQ(composer.cnvSequence("zoj"), "ㄗㄡˋ");
  ASSERT_EQ(composer.cnvSequence("zm"), "ㄗㄢ");
  ASSERT_EQ(composer.cnvSequence("zmd"), "ㄗㄢˊ");
  ASSERT_EQ(composer.cnvSequence("zmf"), "ㄗㄢˇ");
  ASSERT_EQ(composer.cnvSequence("zmj"), "ㄗㄢˋ");
  ASSERT_EQ(composer.cnvSequence("zn"), "ㄗㄣ");
  ASSERT_EQ(composer.cnvSequence("znf"), "ㄗㄣˇ");
  ASSERT_EQ(composer.cnvSequence("znj"), "ㄗㄣˋ");
  ASSERT_EQ(composer.cnvSequence("zk"), "ㄗㄤ");
  ASSERT_EQ(composer.cnvSequence("zkf"), "ㄗㄤˇ");
  ASSERT_EQ(composer.cnvSequence("zkj"), "ㄗㄤˋ");
  ASSERT_EQ(composer.cnvSequence("zl"), "ㄗㄥ");
  ASSERT_EQ(composer.cnvSequence("zlf"), "ㄗㄥˇ");
  ASSERT_EQ(composer.cnvSequence("zlj"), "ㄗㄥˋ");
  ASSERT_EQ(composer.cnvSequence("zx"), "ㄗㄨ");
  ASSERT_EQ(composer.cnvSequence("zxd"), "ㄗㄨˊ");
  ASSERT_EQ(composer.cnvSequence("zxf"), "ㄗㄨˇ");
  ASSERT_EQ(composer.cnvSequence("zxj"), "ㄗㄨˋ");
  ASSERT_EQ(composer.cnvSequence("zxh"), "ㄗㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("zxhd"), "ㄗㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("zxhf"), "ㄗㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("zxhj"), "ㄗㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("zxhs"), "ㄗㄨㄛ˙");
  ASSERT_EQ(composer.cnvSequence("zxa"), "ㄗㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("zxaf"), "ㄗㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("zxaj"), "ㄗㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("zxm"), "ㄗㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("zxmf"), "ㄗㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("zxmj"), "ㄗㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("zxn"), "ㄗㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("zxnf"), "ㄗㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("zxnj"), "ㄗㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("zxl"), "ㄗㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("zxlf"), "ㄗㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("zxlj"), "ㄗㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("a"), "ㄘ");
  ASSERT_EQ(composer.cnvSequence("ad"), "ㄘˊ");
  ASSERT_EQ(composer.cnvSequence("af"), "ㄘˇ");
  ASSERT_EQ(composer.cnvSequence("aj"), "ㄘˋ");
  ASSERT_EQ(composer.cnvSequence("ay"), "ㄘㄚ");
  ASSERT_EQ(composer.cnvSequence("ayf"), "ㄘㄚˇ");
  ASSERT_EQ(composer.cnvSequence("ayj"), "ㄘㄚˋ");
  ASSERT_EQ(composer.cnvSequence("agj"), "ㄘㄜˋ");
  ASSERT_EQ(composer.cnvSequence("ai"), "ㄘㄞ");
  ASSERT_EQ(composer.cnvSequence("aid"), "ㄘㄞˊ");
  ASSERT_EQ(composer.cnvSequence("aif"), "ㄘㄞˇ");
  ASSERT_EQ(composer.cnvSequence("aij"), "ㄘㄞˋ");
  ASSERT_EQ(composer.cnvSequence("aw"), "ㄘㄠ");
  ASSERT_EQ(composer.cnvSequence("awd"), "ㄘㄠˊ");
  ASSERT_EQ(composer.cnvSequence("awf"), "ㄘㄠˇ");
  ASSERT_EQ(composer.cnvSequence("awj"), "ㄘㄠˋ");
  ASSERT_EQ(composer.cnvSequence("ao"), "ㄘㄡ");
  ASSERT_EQ(composer.cnvSequence("aod"), "ㄘㄡˊ");
  ASSERT_EQ(composer.cnvSequence("aof"), "ㄘㄡˇ");
  ASSERT_EQ(composer.cnvSequence("aoj"), "ㄘㄡˋ");
  ASSERT_EQ(composer.cnvSequence("am"), "ㄘㄢ");
  ASSERT_EQ(composer.cnvSequence("amd"), "ㄘㄢˊ");
  ASSERT_EQ(composer.cnvSequence("amf"), "ㄘㄢˇ");
  ASSERT_EQ(composer.cnvSequence("amj"), "ㄘㄢˋ");
  ASSERT_EQ(composer.cnvSequence("an"), "ㄘㄣ");
  ASSERT_EQ(composer.cnvSequence("and"), "ㄘㄣˊ");
  ASSERT_EQ(composer.cnvSequence("ak"), "ㄘㄤ");
  ASSERT_EQ(composer.cnvSequence("akd"), "ㄘㄤˊ");
  ASSERT_EQ(composer.cnvSequence("akf"), "ㄘㄤˇ");
  ASSERT_EQ(composer.cnvSequence("akj"), "ㄘㄤˋ");
  ASSERT_EQ(composer.cnvSequence("al"), "ㄘㄥ");
  ASSERT_EQ(composer.cnvSequence("ald"), "ㄘㄥˊ");
  ASSERT_EQ(composer.cnvSequence("alf"), "ㄘㄥˇ");
  ASSERT_EQ(composer.cnvSequence("alj"), "ㄘㄥˋ");
  ASSERT_EQ(composer.cnvSequence("ax"), "ㄘㄨ");
  ASSERT_EQ(composer.cnvSequence("axd"), "ㄘㄨˊ");
  ASSERT_EQ(composer.cnvSequence("axf"), "ㄘㄨˇ");
  ASSERT_EQ(composer.cnvSequence("axj"), "ㄘㄨˋ");
  ASSERT_EQ(composer.cnvSequence("axh"), "ㄘㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("axhd"), "ㄘㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("axhf"), "ㄘㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("axhj"), "ㄘㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("axa"), "ㄘㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("axaf"), "ㄘㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("axaj"), "ㄘㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("axm"), "ㄘㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("axmd"), "ㄘㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("axmf"), "ㄘㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("axmj"), "ㄘㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("axn"), "ㄘㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("axnd"), "ㄘㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("axnf"), "ㄘㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("axnj"), "ㄘㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("axl"), "ㄘㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("axld"), "ㄘㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("axlf"), "ㄘㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("axlj"), "ㄘㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("s"), "ㄙ");
  ASSERT_EQ(composer.cnvSequence("sf"), "ㄙˇ");
  ASSERT_EQ(composer.cnvSequence("sj"), "ㄙˋ");
  ASSERT_EQ(composer.cnvSequence("sy"), "ㄙㄚ");
  ASSERT_EQ(composer.cnvSequence("syf"), "ㄙㄚˇ");
  ASSERT_EQ(composer.cnvSequence("syj"), "ㄙㄚˋ");
  ASSERT_EQ(composer.cnvSequence("sys"), "ㄙㄚ˙");
  ASSERT_EQ(composer.cnvSequence("sg"), "ㄙㄜ");
  ASSERT_EQ(composer.cnvSequence("sgj"), "ㄙㄜˋ");
  ASSERT_EQ(composer.cnvSequence("si"), "ㄙㄞ");
  ASSERT_EQ(composer.cnvSequence("sid"), "ㄙㄞˊ");
  ASSERT_EQ(composer.cnvSequence("sif"), "ㄙㄞˇ");
  ASSERT_EQ(composer.cnvSequence("sij"), "ㄙㄞˋ");
  ASSERT_EQ(composer.cnvSequence("sa"), "ㄙㄟ");
  ASSERT_EQ(composer.cnvSequence("sw"), "ㄙㄠ");
  ASSERT_EQ(composer.cnvSequence("swf"), "ㄙㄠˇ");
  ASSERT_EQ(composer.cnvSequence("swj"), "ㄙㄠˋ");
  ASSERT_EQ(composer.cnvSequence("so"), "ㄙㄡ");
  ASSERT_EQ(composer.cnvSequence("sof"), "ㄙㄡˇ");
  ASSERT_EQ(composer.cnvSequence("soj"), "ㄙㄡˋ");
  ASSERT_EQ(composer.cnvSequence("sm"), "ㄙㄢ");
  ASSERT_EQ(composer.cnvSequence("smf"), "ㄙㄢˇ");
  ASSERT_EQ(composer.cnvSequence("smj"), "ㄙㄢˋ");
  ASSERT_EQ(composer.cnvSequence("sn"), "ㄙㄣ");
  ASSERT_EQ(composer.cnvSequence("snf"), "ㄙㄣˇ");
  ASSERT_EQ(composer.cnvSequence("sk"), "ㄙㄤ");
  ASSERT_EQ(composer.cnvSequence("skf"), "ㄙㄤˇ");
  ASSERT_EQ(composer.cnvSequence("skj"), "ㄙㄤˋ");
  ASSERT_EQ(composer.cnvSequence("sl"), "ㄙㄥ");
  ASSERT_EQ(composer.cnvSequence("slj"), "ㄙㄥˋ");
  ASSERT_EQ(composer.cnvSequence("sx"), "ㄙㄨ");
  ASSERT_EQ(composer.cnvSequence("sxd"), "ㄙㄨˊ");
  ASSERT_EQ(composer.cnvSequence("sxf"), "ㄙㄨˇ");
  ASSERT_EQ(composer.cnvSequence("sxj"), "ㄙㄨˋ");
  ASSERT_EQ(composer.cnvSequence("sxh"), "ㄙㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("sxhd"), "ㄙㄨㄛˊ");
  ASSERT_EQ(composer.cnvSequence("sxhf"), "ㄙㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("sxhj"), "ㄙㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("sxa"), "ㄙㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("sxad"), "ㄙㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("sxaf"), "ㄙㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("sxaj"), "ㄙㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("sxm"), "ㄙㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("sxmf"), "ㄙㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("sxmj"), "ㄙㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("sxn"), "ㄙㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("sxnf"), "ㄙㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("sxnj"), "ㄙㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("sxl"), "ㄙㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("sxld"), "ㄙㄨㄥˊ");
  ASSERT_EQ(composer.cnvSequence("sxlf"), "ㄙㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("sxlj"), "ㄙㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("y"), "ㄚ");
  ASSERT_EQ(composer.cnvSequence("yd"), "ㄚˊ");
  ASSERT_EQ(composer.cnvSequence("yj"), "ㄚˋ");
  ASSERT_EQ(composer.cnvSequence("ys"), "ㄚ˙");
  ASSERT_EQ(composer.cnvSequence("h"), "ㄛ");
  ASSERT_EQ(composer.cnvSequence("hd"), "ㄛˊ");
  ASSERT_EQ(composer.cnvSequence("hf"), "ㄛˇ");
  ASSERT_EQ(composer.cnvSequence("hj"), "ㄛˋ");
  ASSERT_EQ(composer.cnvSequence("g"), "ㄜ");
  ASSERT_EQ(composer.cnvSequence("gd"), "ㄜˊ");
  ASSERT_EQ(composer.cnvSequence("gf"), "ㄜˇ");
  ASSERT_EQ(composer.cnvSequence("gj"), "ㄜˋ");
  // ASSERT_EQ(composer.cnvSequence("ed"), "ㄝˊ");
  // ASSERT_EQ(composer.cnvSequence("ef"), "ㄝˇ");
  // ASSERT_EQ(composer.cnvSequence("ej"), "ㄝˋ");
  // ASSERT_EQ(composer.cnvSequence("es"), "ㄝ˙");
  ASSERT_EQ(composer.cnvSequence("i"), "ㄞ");
  ASSERT_EQ(composer.cnvSequence("id"), "ㄞˊ");
  ASSERT_EQ(composer.cnvSequence("if"), "ㄞˇ");
  ASSERT_EQ(composer.cnvSequence("ij"), "ㄞˋ");
  // ASSERT_EQ(composer.cnvSequence("aj"), "ㄟˋ");
  ASSERT_EQ(composer.cnvSequence("w"), "ㄠ");
  ASSERT_EQ(composer.cnvSequence("wd"), "ㄠˊ");
  ASSERT_EQ(composer.cnvSequence("wf"), "ㄠˇ");
  ASSERT_EQ(composer.cnvSequence("wj"), "ㄠˋ");
  ASSERT_EQ(composer.cnvSequence("o"), "ㄡ");
  ASSERT_EQ(composer.cnvSequence("od"), "ㄡˊ");
  ASSERT_EQ(composer.cnvSequence("of"), "ㄡˇ");
  ASSERT_EQ(composer.cnvSequence("oj"), "ㄡˋ");
  ASSERT_EQ(composer.cnvSequence("os"), "ㄡ˙");
  ASSERT_EQ(composer.cnvSequence("m"), "ㄢ");
  ASSERT_EQ(composer.cnvSequence("md"), "ㄢˊ");
  ASSERT_EQ(composer.cnvSequence("mf"), "ㄢˇ");
  ASSERT_EQ(composer.cnvSequence("mj"), "ㄢˋ");
  ASSERT_EQ(composer.cnvSequence("n"), "ㄣ");
  ASSERT_EQ(composer.cnvSequence("nd"), "ㄣˊ");
  ASSERT_EQ(composer.cnvSequence("nf"), "ㄣˇ");
  ASSERT_EQ(composer.cnvSequence("nj"), "ㄣˋ");
  ASSERT_EQ(composer.cnvSequence("ns"), "ㄣ˙");
  ASSERT_EQ(composer.cnvSequence("k"), "ㄤ");
  ASSERT_EQ(composer.cnvSequence("kd"), "ㄤˊ");
  ASSERT_EQ(composer.cnvSequence("kf"), "ㄤˇ");
  ASSERT_EQ(composer.cnvSequence("kj"), "ㄤˋ");
  // ASSERT_EQ(composer.cnvSequence("l"), "ㄥ");
  // ASSERT_EQ(composer.cnvSequence("lj"), "ㄥˋ");
  ASSERT_EQ(composer.cnvSequence("l"), "ㄦ");
  ASSERT_EQ(composer.cnvSequence("ld"), "ㄦˊ");
  ASSERT_EQ(composer.cnvSequence("lf"), "ㄦˇ");
  ASSERT_EQ(composer.cnvSequence("lj"), "ㄦˋ");
  ASSERT_EQ(composer.cnvSequence("ls"), "ㄦ˙");
  ASSERT_EQ(composer.cnvSequence("e"), "ㄧ");
  ASSERT_EQ(composer.cnvSequence("ed"), "ㄧˊ");
  ASSERT_EQ(composer.cnvSequence("ef"), "ㄧˇ");
  ASSERT_EQ(composer.cnvSequence("ej"), "ㄧˋ");
  ASSERT_EQ(composer.cnvSequence("ey"), "ㄧㄚ");
  ASSERT_EQ(composer.cnvSequence("eyd"), "ㄧㄚˊ");
  ASSERT_EQ(composer.cnvSequence("eyf"), "ㄧㄚˇ");
  ASSERT_EQ(composer.cnvSequence("eyj"), "ㄧㄚˋ");
  ASSERT_EQ(composer.cnvSequence("eys"), "ㄧㄚ˙");
  ASSERT_EQ(composer.cnvSequence("eh"), "ㄧㄛ");
  ASSERT_EQ(composer.cnvSequence("ehs"), "ㄧㄛ˙");
  ASSERT_EQ(composer.cnvSequence("ee"), "ㄧㄝ");
  ASSERT_EQ(composer.cnvSequence("eed"), "ㄧㄝˊ");
  ASSERT_EQ(composer.cnvSequence("eef"), "ㄧㄝˇ");
  ASSERT_EQ(composer.cnvSequence("eej"), "ㄧㄝˋ");
  ASSERT_EQ(composer.cnvSequence("ees"), "ㄧㄝ˙");
  ASSERT_EQ(composer.cnvSequence("eid"), "ㄧㄞˊ");
  ASSERT_EQ(composer.cnvSequence("ew"), "ㄧㄠ");
  ASSERT_EQ(composer.cnvSequence("ewd"), "ㄧㄠˊ");
  ASSERT_EQ(composer.cnvSequence("ewf"), "ㄧㄠˇ");
  ASSERT_EQ(composer.cnvSequence("ewj"), "ㄧㄠˋ");
  ASSERT_EQ(composer.cnvSequence("eo"), "ㄧㄡ");
  ASSERT_EQ(composer.cnvSequence("eod"), "ㄧㄡˊ");
  ASSERT_EQ(composer.cnvSequence("eof"), "ㄧㄡˇ");
  ASSERT_EQ(composer.cnvSequence("eoj"), "ㄧㄡˋ");
  ASSERT_EQ(composer.cnvSequence("em"), "ㄧㄢ");
  ASSERT_EQ(composer.cnvSequence("emd"), "ㄧㄢˊ");
  ASSERT_EQ(composer.cnvSequence("emf"), "ㄧㄢˇ");
  ASSERT_EQ(composer.cnvSequence("emj"), "ㄧㄢˋ");
  ASSERT_EQ(composer.cnvSequence("en"), "ㄧㄣ");
  ASSERT_EQ(composer.cnvSequence("end"), "ㄧㄣˊ");
  ASSERT_EQ(composer.cnvSequence("enf"), "ㄧㄣˇ");
  ASSERT_EQ(composer.cnvSequence("enj"), "ㄧㄣˋ");
  ASSERT_EQ(composer.cnvSequence("ek"), "ㄧㄤ");
  ASSERT_EQ(composer.cnvSequence("ekd"), "ㄧㄤˊ");
  ASSERT_EQ(composer.cnvSequence("ekf"), "ㄧㄤˇ");
  ASSERT_EQ(composer.cnvSequence("ekj"), "ㄧㄤˋ");
  ASSERT_EQ(composer.cnvSequence("el"), "ㄧㄥ");
  ASSERT_EQ(composer.cnvSequence("eld"), "ㄧㄥˊ");
  ASSERT_EQ(composer.cnvSequence("elf"), "ㄧㄥˇ");
  ASSERT_EQ(composer.cnvSequence("elj"), "ㄧㄥˋ");
  ASSERT_EQ(composer.cnvSequence("x"), "ㄨ");
  ASSERT_EQ(composer.cnvSequence("xd"), "ㄨˊ");
  ASSERT_EQ(composer.cnvSequence("xf"), "ㄨˇ");
  ASSERT_EQ(composer.cnvSequence("xj"), "ㄨˋ");
  ASSERT_EQ(composer.cnvSequence("xy"), "ㄨㄚ");
  ASSERT_EQ(composer.cnvSequence("xyd"), "ㄨㄚˊ");
  ASSERT_EQ(composer.cnvSequence("xyf"), "ㄨㄚˇ");
  ASSERT_EQ(composer.cnvSequence("xyj"), "ㄨㄚˋ");
  ASSERT_EQ(composer.cnvSequence("xys"), "ㄨㄚ˙");
  ASSERT_EQ(composer.cnvSequence("xh"), "ㄨㄛ");
  ASSERT_EQ(composer.cnvSequence("xhf"), "ㄨㄛˇ");
  ASSERT_EQ(composer.cnvSequence("xhj"), "ㄨㄛˋ");
  ASSERT_EQ(composer.cnvSequence("xi"), "ㄨㄞ");
  ASSERT_EQ(composer.cnvSequence("xif"), "ㄨㄞˇ");
  ASSERT_EQ(composer.cnvSequence("xij"), "ㄨㄞˋ");
  ASSERT_EQ(composer.cnvSequence("xa"), "ㄨㄟ");
  ASSERT_EQ(composer.cnvSequence("xad"), "ㄨㄟˊ");
  ASSERT_EQ(composer.cnvSequence("xaf"), "ㄨㄟˇ");
  ASSERT_EQ(composer.cnvSequence("xaj"), "ㄨㄟˋ");
  ASSERT_EQ(composer.cnvSequence("xm"), "ㄨㄢ");
  ASSERT_EQ(composer.cnvSequence("xmd"), "ㄨㄢˊ");
  ASSERT_EQ(composer.cnvSequence("xmf"), "ㄨㄢˇ");
  ASSERT_EQ(composer.cnvSequence("xmj"), "ㄨㄢˋ");
  ASSERT_EQ(composer.cnvSequence("xn"), "ㄨㄣ");
  ASSERT_EQ(composer.cnvSequence("xnd"), "ㄨㄣˊ");
  ASSERT_EQ(composer.cnvSequence("xnf"), "ㄨㄣˇ");
  ASSERT_EQ(composer.cnvSequence("xnj"), "ㄨㄣˋ");
  ASSERT_EQ(composer.cnvSequence("xk"), "ㄨㄤ");
  ASSERT_EQ(composer.cnvSequence("xkd"), "ㄨㄤˊ");
  ASSERT_EQ(composer.cnvSequence("xkf"), "ㄨㄤˇ");
  ASSERT_EQ(composer.cnvSequence("xkj"), "ㄨㄤˋ");
  ASSERT_EQ(composer.cnvSequence("xl"), "ㄨㄥ");
  ASSERT_EQ(composer.cnvSequence("xlf"), "ㄨㄥˇ");
  ASSERT_EQ(composer.cnvSequence("xlj"), "ㄨㄥˋ");
  ASSERT_EQ(composer.cnvSequence("u"), "ㄩ");
  ASSERT_EQ(composer.cnvSequence("ud"), "ㄩˊ");
  ASSERT_EQ(composer.cnvSequence("uf"), "ㄩˇ");
  ASSERT_EQ(composer.cnvSequence("uj"), "ㄩˋ");
  ASSERT_EQ(composer.cnvSequence("ue"), "ㄩㄝ");
  ASSERT_EQ(composer.cnvSequence("uef"), "ㄩㄝˇ");
  ASSERT_EQ(composer.cnvSequence("uej"), "ㄩㄝˋ");
  ASSERT_EQ(composer.cnvSequence("um"), "ㄩㄢ");
  ASSERT_EQ(composer.cnvSequence("umd"), "ㄩㄢˊ");
  ASSERT_EQ(composer.cnvSequence("umf"), "ㄩㄢˇ");
  ASSERT_EQ(composer.cnvSequence("umj"), "ㄩㄢˋ");
  ASSERT_EQ(composer.cnvSequence("un"), "ㄩㄣ");
  ASSERT_EQ(composer.cnvSequence("und"), "ㄩㄣˊ");
  ASSERT_EQ(composer.cnvSequence("unf"), "ㄩㄣˇ");
  ASSERT_EQ(composer.cnvSequence("unj"), "ㄩㄣˋ");
  ASSERT_EQ(composer.cnvSequence("ul"), "ㄩㄥ");
  ASSERT_EQ(composer.cnvSequence("uld"), "ㄩㄥˊ");
  ASSERT_EQ(composer.cnvSequence("ulf"), "ㄩㄥˇ");
  ASSERT_EQ(composer.cnvSequence("ulj"), "ㄩㄥˋ");
}
} // namespace Mandarin
} // namespace Formosa

## MandarinTests.mm
// This test file is written by Shiki Suen (MIT License).
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

#import "Mandarin.h"
#import <XCTest/XCTest.h>

using namespace Formosa::Mandarin;

@interface MandarinTests : XCTestCase

@end

@implementation MandarinTests

- (void)testDachen {
  BopomofoReadingBuffer composer(BopomofoKeyboardLayout::StandardLayout());
  XCTAssertEqual(composer.cnvSequence("18"), "ㄅㄚ");
  XCTAssertEqual(composer.cnvSequence("m,4"), "ㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("5j/"), "ㄓㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("fu."), "ㄑㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("g0"), "ㄕㄢ");
  XCTAssertEqual(composer.cnvSequence("xup6"), "ㄌㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("xu;6"), "ㄌㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("z/"), "ㄈㄥ");
  XCTAssertEqual(composer.cnvSequence("tjo"), "ㄔㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("284"), "ㄉㄚˋ");
  XCTAssertEqual(composer.cnvSequence("2u4"), "ㄉㄧˋ");
  XCTAssertEqual(composer.cnvSequence("hl3"), "ㄘㄠˇ");
  XCTAssertEqual(composer.cnvSequence("5"), "ㄓ");
  XCTAssertEqual(composer.cnvSequence("193"), "ㄅㄞˇ");
}

- (void)testEten26 {
  BopomofoReadingBuffer composer(BopomofoKeyboardLayout::ETen26Layout());
  XCTAssertEqual(composer.cnvSequence("ket"), "ㄎㄧㄤ");
  // AreEqual(Composer.cnvSequence("vezf"), "ㄍㄧㄠˊ");
  // AreEqual(Composer.cnvSequence("ven"), "ㄍㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("betf"), "ㄅㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("betk"), "ㄅㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("dxt"), "ㄉㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("ba"), "ㄅㄚ");
  XCTAssertEqual(composer.cnvSequence("baf"), "ㄅㄚˊ");
  XCTAssertEqual(composer.cnvSequence("baj"), "ㄅㄚˇ");
  XCTAssertEqual(composer.cnvSequence("bak"), "ㄅㄚˋ");
  XCTAssertEqual(composer.cnvSequence("bad"), "ㄅㄚ˙");
  XCTAssertEqual(composer.cnvSequence("bo"), "ㄅㄛ");
  XCTAssertEqual(composer.cnvSequence("bof"), "ㄅㄛˊ");
  XCTAssertEqual(composer.cnvSequence("boj"), "ㄅㄛˇ");
  XCTAssertEqual(composer.cnvSequence("bok"), "ㄅㄛˋ");
  XCTAssertEqual(composer.cnvSequence("bod"), "ㄅㄛ˙");
  XCTAssertEqual(composer.cnvSequence("bi"), "ㄅㄞ");
  XCTAssertEqual(composer.cnvSequence("bif"), "ㄅㄞˊ");
  XCTAssertEqual(composer.cnvSequence("bij"), "ㄅㄞˇ");
  XCTAssertEqual(composer.cnvSequence("bik"), "ㄅㄞˋ");
  XCTAssertEqual(composer.cnvSequence("bid"), "ㄅㄞ˙");
  XCTAssertEqual(composer.cnvSequence("bq"), "ㄅㄟ");
  XCTAssertEqual(composer.cnvSequence("bqj"), "ㄅㄟˇ");
  XCTAssertEqual(composer.cnvSequence("bqk"), "ㄅㄟˋ");
  XCTAssertEqual(composer.cnvSequence("bqd"), "ㄅㄟ˙");
  XCTAssertEqual(composer.cnvSequence("bz"), "ㄅㄠ");
  XCTAssertEqual(composer.cnvSequence("bzf"), "ㄅㄠˊ");
  XCTAssertEqual(composer.cnvSequence("bzj"), "ㄅㄠˇ");
  XCTAssertEqual(composer.cnvSequence("bzk"), "ㄅㄠˋ");
  XCTAssertEqual(composer.cnvSequence("bm"), "ㄅㄢ");
  XCTAssertEqual(composer.cnvSequence("bmj"), "ㄅㄢˇ");
  XCTAssertEqual(composer.cnvSequence("bmk"), "ㄅㄢˋ");
  XCTAssertEqual(composer.cnvSequence("bn"), "ㄅㄣ");
  XCTAssertEqual(composer.cnvSequence("bnj"), "ㄅㄣˇ");
  XCTAssertEqual(composer.cnvSequence("bnk"), "ㄅㄣˋ");
  XCTAssertEqual(composer.cnvSequence("bt"), "ㄅㄤ");
  XCTAssertEqual(composer.cnvSequence("btj"), "ㄅㄤˇ");
  XCTAssertEqual(composer.cnvSequence("btk"), "ㄅㄤˋ");
  XCTAssertEqual(composer.cnvSequence("bl"), "ㄅㄥ");
  XCTAssertEqual(composer.cnvSequence("blf"), "ㄅㄥˊ");
  XCTAssertEqual(composer.cnvSequence("blj"), "ㄅㄥˇ");
  XCTAssertEqual(composer.cnvSequence("blk"), "ㄅㄥˋ");
  XCTAssertEqual(composer.cnvSequence("be"), "ㄅㄧ");
  XCTAssertEqual(composer.cnvSequence("bef"), "ㄅㄧˊ");
  XCTAssertEqual(composer.cnvSequence("bej"), "ㄅㄧˇ");
  XCTAssertEqual(composer.cnvSequence("bek"), "ㄅㄧˋ");
  XCTAssertEqual(composer.cnvSequence("bew"), "ㄅㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("bewf"), "ㄅㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("bewj"), "ㄅㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("bewk"), "ㄅㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("bez"), "ㄅㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("bezj"), "ㄅㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("bezk"), "ㄅㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("bem"), "ㄅㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("bemf"), "ㄅㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("bemj"), "ㄅㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("bemk"), "ㄅㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("ben"), "ㄅㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("benj"), "ㄅㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("benk"), "ㄅㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("bel"), "ㄅㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("belj"), "ㄅㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("belk"), "ㄅㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("bx"), "ㄅㄨ");
  XCTAssertEqual(composer.cnvSequence("bxf"), "ㄅㄨˊ");
  XCTAssertEqual(composer.cnvSequence("bxj"), "ㄅㄨˇ");
  XCTAssertEqual(composer.cnvSequence("bxk"), "ㄅㄨˋ");
  XCTAssertEqual(composer.cnvSequence("pa"), "ㄆㄚ");
  XCTAssertEqual(composer.cnvSequence("paf"), "ㄆㄚˊ");
  XCTAssertEqual(composer.cnvSequence("paj"), "ㄆㄚˇ");
  XCTAssertEqual(composer.cnvSequence("pak"), "ㄆㄚˋ");
  XCTAssertEqual(composer.cnvSequence("pad"), "ㄆㄚ˙");
  XCTAssertEqual(composer.cnvSequence("po"), "ㄆㄛ");
  XCTAssertEqual(composer.cnvSequence("pof"), "ㄆㄛˊ");
  XCTAssertEqual(composer.cnvSequence("poj"), "ㄆㄛˇ");
  XCTAssertEqual(composer.cnvSequence("pok"), "ㄆㄛˋ");
  XCTAssertEqual(composer.cnvSequence("pi"), "ㄆㄞ");
  XCTAssertEqual(composer.cnvSequence("pif"), "ㄆㄞˊ");
  XCTAssertEqual(composer.cnvSequence("pij"), "ㄆㄞˇ");
  XCTAssertEqual(composer.cnvSequence("pik"), "ㄆㄞˋ");
  XCTAssertEqual(composer.cnvSequence("pq"), "ㄆㄟ");
  XCTAssertEqual(composer.cnvSequence("pqf"), "ㄆㄟˊ");
  XCTAssertEqual(composer.cnvSequence("pqj"), "ㄆㄟˇ");
  XCTAssertEqual(composer.cnvSequence("pqk"), "ㄆㄟˋ");
  XCTAssertEqual(composer.cnvSequence("pz"), "ㄆㄠ");
  XCTAssertEqual(composer.cnvSequence("pzf"), "ㄆㄠˊ");
  XCTAssertEqual(composer.cnvSequence("pzj"), "ㄆㄠˇ");
  XCTAssertEqual(composer.cnvSequence("pzk"), "ㄆㄠˋ");
  XCTAssertEqual(composer.cnvSequence("pp"), "ㄆㄡ");
  XCTAssertEqual(composer.cnvSequence("ppf"), "ㄆㄡˊ");
  XCTAssertEqual(composer.cnvSequence("ppj"), "ㄆㄡˇ");
  XCTAssertEqual(composer.cnvSequence("ppk"), "ㄆㄡˋ");
  XCTAssertEqual(composer.cnvSequence("pm"), "ㄆㄢ");
  XCTAssertEqual(composer.cnvSequence("pmf"), "ㄆㄢˊ");
  XCTAssertEqual(composer.cnvSequence("pmj"), "ㄆㄢˇ");
  XCTAssertEqual(composer.cnvSequence("pmk"), "ㄆㄢˋ");
  XCTAssertEqual(composer.cnvSequence("pn"), "ㄆㄣ");
  XCTAssertEqual(composer.cnvSequence("pnf"), "ㄆㄣˊ");
  XCTAssertEqual(composer.cnvSequence("pnj"), "ㄆㄣˇ");
  XCTAssertEqual(composer.cnvSequence("pnk"), "ㄆㄣˋ");
  XCTAssertEqual(composer.cnvSequence("pt"), "ㄆㄤ");
  XCTAssertEqual(composer.cnvSequence("ptf"), "ㄆㄤˊ");
  XCTAssertEqual(composer.cnvSequence("ptj"), "ㄆㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ptk"), "ㄆㄤˋ");
  XCTAssertEqual(composer.cnvSequence("pl"), "ㄆㄥ");
  XCTAssertEqual(composer.cnvSequence("plf"), "ㄆㄥˊ");
  XCTAssertEqual(composer.cnvSequence("plj"), "ㄆㄥˇ");
  XCTAssertEqual(composer.cnvSequence("plk"), "ㄆㄥˋ");
  XCTAssertEqual(composer.cnvSequence("pe"), "ㄆㄧ");
  XCTAssertEqual(composer.cnvSequence("pef"), "ㄆㄧˊ");
  XCTAssertEqual(composer.cnvSequence("pej"), "ㄆㄧˇ");
  XCTAssertEqual(composer.cnvSequence("pek"), "ㄆㄧˋ");
  XCTAssertEqual(composer.cnvSequence("pea"), "ㄆㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("pew"), "ㄆㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("pewj"), "ㄆㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("pewk"), "ㄆㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("pez"), "ㄆㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("pezf"), "ㄆㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("pezj"), "ㄆㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("pezk"), "ㄆㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("pem"), "ㄆㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("pemf"), "ㄆㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("pemj"), "ㄆㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("pemk"), "ㄆㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("pen"), "ㄆㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("penf"), "ㄆㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("penj"), "ㄆㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("penk"), "ㄆㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("pel"), "ㄆㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("pelf"), "ㄆㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("pelj"), "ㄆㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("pelk"), "ㄆㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("px"), "ㄆㄨ");
  XCTAssertEqual(composer.cnvSequence("pxf"), "ㄆㄨˊ");
  XCTAssertEqual(composer.cnvSequence("pxj"), "ㄆㄨˇ");
  XCTAssertEqual(composer.cnvSequence("pxk"), "ㄆㄨˋ");
  XCTAssertEqual(composer.cnvSequence("ma"), "ㄇㄚ");
  XCTAssertEqual(composer.cnvSequence("maf"), "ㄇㄚˊ");
  XCTAssertEqual(composer.cnvSequence("maj"), "ㄇㄚˇ");
  XCTAssertEqual(composer.cnvSequence("mak"), "ㄇㄚˋ");
  XCTAssertEqual(composer.cnvSequence("mad"), "ㄇㄚ˙");
  XCTAssertEqual(composer.cnvSequence("mo"), "ㄇㄛ");
  XCTAssertEqual(composer.cnvSequence("mof"), "ㄇㄛˊ");
  XCTAssertEqual(composer.cnvSequence("moj"), "ㄇㄛˇ");
  XCTAssertEqual(composer.cnvSequence("mok"), "ㄇㄛˋ");
  XCTAssertEqual(composer.cnvSequence("mod"), "ㄇㄛ˙");
  XCTAssertEqual(composer.cnvSequence("mr"), "ㄇㄜ");
  XCTAssertEqual(composer.cnvSequence("mrk"), "ㄇㄜˋ");
  XCTAssertEqual(composer.cnvSequence("mrd"), "ㄇㄜ˙");
  XCTAssertEqual(composer.cnvSequence("mi"), "ㄇㄞ");
  XCTAssertEqual(composer.cnvSequence("mif"), "ㄇㄞˊ");
  XCTAssertEqual(composer.cnvSequence("mij"), "ㄇㄞˇ");
  XCTAssertEqual(composer.cnvSequence("mik"), "ㄇㄞˋ");
  XCTAssertEqual(composer.cnvSequence("mqf"), "ㄇㄟˊ");
  XCTAssertEqual(composer.cnvSequence("mqj"), "ㄇㄟˇ");
  XCTAssertEqual(composer.cnvSequence("mqk"), "ㄇㄟˋ");
  XCTAssertEqual(composer.cnvSequence("mz"), "ㄇㄠ");
  XCTAssertEqual(composer.cnvSequence("mzf"), "ㄇㄠˊ");
  XCTAssertEqual(composer.cnvSequence("mzj"), "ㄇㄠˇ");
  XCTAssertEqual(composer.cnvSequence("mzk"), "ㄇㄠˋ");
  XCTAssertEqual(composer.cnvSequence("mpf"), "ㄇㄡˊ");
  XCTAssertEqual(composer.cnvSequence("mpj"), "ㄇㄡˇ");
  XCTAssertEqual(composer.cnvSequence("mpk"), "ㄇㄡˋ");
  XCTAssertEqual(composer.cnvSequence("mm"), "ㄇㄢ");
  XCTAssertEqual(composer.cnvSequence("mmf"), "ㄇㄢˊ");
  XCTAssertEqual(composer.cnvSequence("mmj"), "ㄇㄢˇ");
  XCTAssertEqual(composer.cnvSequence("mmk"), "ㄇㄢˋ");
  XCTAssertEqual(composer.cnvSequence("mn"), "ㄇㄣ");
  XCTAssertEqual(composer.cnvSequence("mnf"), "ㄇㄣˊ");
  XCTAssertEqual(composer.cnvSequence("mnj"), "ㄇㄣˇ");
  XCTAssertEqual(composer.cnvSequence("mnk"), "ㄇㄣˋ");
  XCTAssertEqual(composer.cnvSequence("mnd"), "ㄇㄣ˙");
  XCTAssertEqual(composer.cnvSequence("mt"), "ㄇㄤ");
  XCTAssertEqual(composer.cnvSequence("mtf"), "ㄇㄤˊ");
  XCTAssertEqual(composer.cnvSequence("mtj"), "ㄇㄤˇ");
  XCTAssertEqual(composer.cnvSequence("mtk"), "ㄇㄤˋ");
  XCTAssertEqual(composer.cnvSequence("ml"), "ㄇㄥ");
  XCTAssertEqual(composer.cnvSequence("mlf"), "ㄇㄥˊ");
  XCTAssertEqual(composer.cnvSequence("mlj"), "ㄇㄥˇ");
  XCTAssertEqual(composer.cnvSequence("mlk"), "ㄇㄥˋ");
  XCTAssertEqual(composer.cnvSequence("me"), "ㄇㄧ");
  XCTAssertEqual(composer.cnvSequence("mef"), "ㄇㄧˊ");
  XCTAssertEqual(composer.cnvSequence("mej"), "ㄇㄧˇ");
  XCTAssertEqual(composer.cnvSequence("mek"), "ㄇㄧˋ");
  XCTAssertEqual(composer.cnvSequence("mew"), "ㄇㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("mewf"), "ㄇㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("mewk"), "ㄇㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("mez"), "ㄇㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("mezf"), "ㄇㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("mezj"), "ㄇㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("mezk"), "ㄇㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("mepf"), "ㄇㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("mepj"), "ㄇㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("mepk"), "ㄇㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("mem"), "ㄇㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("memf"), "ㄇㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("memj"), "ㄇㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("memk"), "ㄇㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("men"), "ㄇㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("menf"), "ㄇㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("menj"), "ㄇㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("melf"), "ㄇㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("melj"), "ㄇㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("melk"), "ㄇㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("mxf"), "ㄇㄨˊ");
  XCTAssertEqual(composer.cnvSequence("mxj"), "ㄇㄨˇ");
  XCTAssertEqual(composer.cnvSequence("mxk"), "ㄇㄨˋ");
  XCTAssertEqual(composer.cnvSequence("fa"), "ㄈㄚ");
  XCTAssertEqual(composer.cnvSequence("faf"), "ㄈㄚˊ");
  XCTAssertEqual(composer.cnvSequence("faj"), "ㄈㄚˇ");
  XCTAssertEqual(composer.cnvSequence("fak"), "ㄈㄚˋ");
  XCTAssertEqual(composer.cnvSequence("fof"), "ㄈㄛˊ");
  XCTAssertEqual(composer.cnvSequence("fq"), "ㄈㄟ");
  XCTAssertEqual(composer.cnvSequence("fqf"), "ㄈㄟˊ");
  XCTAssertEqual(composer.cnvSequence("fqj"), "ㄈㄟˇ");
  XCTAssertEqual(composer.cnvSequence("fqk"), "ㄈㄟˋ");
  XCTAssertEqual(composer.cnvSequence("fp"), "ㄈㄡ");
  XCTAssertEqual(composer.cnvSequence("fpf"), "ㄈㄡˊ");
  XCTAssertEqual(composer.cnvSequence("fpj"), "ㄈㄡˇ");
  XCTAssertEqual(composer.cnvSequence("fpk"), "ㄈㄡˋ");
  XCTAssertEqual(composer.cnvSequence("fm"), "ㄈㄢ");
  XCTAssertEqual(composer.cnvSequence("fmf"), "ㄈㄢˊ");
  XCTAssertEqual(composer.cnvSequence("fmj"), "ㄈㄢˇ");
  XCTAssertEqual(composer.cnvSequence("fmk"), "ㄈㄢˋ");
  XCTAssertEqual(composer.cnvSequence("fn"), "ㄈㄣ");
  XCTAssertEqual(composer.cnvSequence("fnf"), "ㄈㄣˊ");
  XCTAssertEqual(composer.cnvSequence("fnj"), "ㄈㄣˇ");
  XCTAssertEqual(composer.cnvSequence("fnk"), "ㄈㄣˋ");
  XCTAssertEqual(composer.cnvSequence("fnd"), "ㄈㄣ˙");
  XCTAssertEqual(composer.cnvSequence("ft"), "ㄈㄤ");
  XCTAssertEqual(composer.cnvSequence("ftf"), "ㄈㄤˊ");
  XCTAssertEqual(composer.cnvSequence("ftj"), "ㄈㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ftk"), "ㄈㄤˋ");
  XCTAssertEqual(composer.cnvSequence("fl"), "ㄈㄥ");
  XCTAssertEqual(composer.cnvSequence("flf"), "ㄈㄥˊ");
  XCTAssertEqual(composer.cnvSequence("flj"), "ㄈㄥˇ");
  XCTAssertEqual(composer.cnvSequence("flk"), "ㄈㄥˋ");
  XCTAssertEqual(composer.cnvSequence("fezk"), "ㄈㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("fx"), "ㄈㄨ");
  XCTAssertEqual(composer.cnvSequence("fxf"), "ㄈㄨˊ");
  XCTAssertEqual(composer.cnvSequence("fxj"), "ㄈㄨˇ");
  XCTAssertEqual(composer.cnvSequence("fxk"), "ㄈㄨˋ");
  XCTAssertEqual(composer.cnvSequence("da"), "ㄉㄚ");
  XCTAssertEqual(composer.cnvSequence("daf"), "ㄉㄚˊ");
  XCTAssertEqual(composer.cnvSequence("daj"), "ㄉㄚˇ");
  XCTAssertEqual(composer.cnvSequence("dak"), "ㄉㄚˋ");
  XCTAssertEqual(composer.cnvSequence("dad"), "ㄉㄚ˙");
  XCTAssertEqual(composer.cnvSequence("dr"), "ㄉㄜ");
  XCTAssertEqual(composer.cnvSequence("drf"), "ㄉㄜˊ");
  XCTAssertEqual(composer.cnvSequence("drd"), "ㄉㄜ˙");
  XCTAssertEqual(composer.cnvSequence("di"), "ㄉㄞ");
  XCTAssertEqual(composer.cnvSequence("dij"), "ㄉㄞˇ");
  XCTAssertEqual(composer.cnvSequence("dik"), "ㄉㄞˋ");
  XCTAssertEqual(composer.cnvSequence("dqj"), "ㄉㄟˇ");
  XCTAssertEqual(composer.cnvSequence("dz"), "ㄉㄠ");
  XCTAssertEqual(composer.cnvSequence("dzf"), "ㄉㄠˊ");
  XCTAssertEqual(composer.cnvSequence("dzj"), "ㄉㄠˇ");
  XCTAssertEqual(composer.cnvSequence("dzk"), "ㄉㄠˋ");
  XCTAssertEqual(composer.cnvSequence("dp"), "ㄉㄡ");
  XCTAssertEqual(composer.cnvSequence("dpf"), "ㄉㄡˊ");
  XCTAssertEqual(composer.cnvSequence("dpj"), "ㄉㄡˇ");
  XCTAssertEqual(composer.cnvSequence("dpk"), "ㄉㄡˋ");
  XCTAssertEqual(composer.cnvSequence("dm"), "ㄉㄢ");
  XCTAssertEqual(composer.cnvSequence("dmj"), "ㄉㄢˇ");
  XCTAssertEqual(composer.cnvSequence("dmk"), "ㄉㄢˋ");
  XCTAssertEqual(composer.cnvSequence("dnk"), "ㄉㄣˋ");
  XCTAssertEqual(composer.cnvSequence("dt"), "ㄉㄤ");
  XCTAssertEqual(composer.cnvSequence("dtj"), "ㄉㄤˇ");
  XCTAssertEqual(composer.cnvSequence("dtk"), "ㄉㄤˋ");
  XCTAssertEqual(composer.cnvSequence("dl"), "ㄉㄥ");
  XCTAssertEqual(composer.cnvSequence("dlj"), "ㄉㄥˇ");
  XCTAssertEqual(composer.cnvSequence("dlk"), "ㄉㄥˋ");
  XCTAssertEqual(composer.cnvSequence("de"), "ㄉㄧ");
  XCTAssertEqual(composer.cnvSequence("def"), "ㄉㄧˊ");
  XCTAssertEqual(composer.cnvSequence("dej"), "ㄉㄧˇ");
  XCTAssertEqual(composer.cnvSequence("dek"), "ㄉㄧˋ");
  XCTAssertEqual(composer.cnvSequence("deaj"), "ㄉㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("dew"), "ㄉㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("dewf"), "ㄉㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("dewj"), "ㄉㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("dewk"), "ㄉㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("dez"), "ㄉㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("dezj"), "ㄉㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("dezk"), "ㄉㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("dep"), "ㄉㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("dem"), "ㄉㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("demf"), "ㄉㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("demj"), "ㄉㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("demk"), "ㄉㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("del"), "ㄉㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("delf"), "ㄉㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("delj"), "ㄉㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("delk"), "ㄉㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("dx"), "ㄉㄨ");
  XCTAssertEqual(composer.cnvSequence("dxf"), "ㄉㄨˊ");
  XCTAssertEqual(composer.cnvSequence("dxj"), "ㄉㄨˇ");
  XCTAssertEqual(composer.cnvSequence("dxk"), "ㄉㄨˋ");
  XCTAssertEqual(composer.cnvSequence("dxo"), "ㄉㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("dxof"), "ㄉㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("dxoj"), "ㄉㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("dxok"), "ㄉㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("dxod"), "ㄉㄨㄛ˙");
  XCTAssertEqual(composer.cnvSequence("dxq"), "ㄉㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("dxqj"), "ㄉㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("dxqk"), "ㄉㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("dxm"), "ㄉㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("dxmj"), "ㄉㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("dxmk"), "ㄉㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("dxn"), "ㄉㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("dxnj"), "ㄉㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("dxnk"), "ㄉㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("dxl"), "ㄉㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("dxlj"), "ㄉㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("dxlk"), "ㄉㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ta"), "ㄊㄚ");
  XCTAssertEqual(composer.cnvSequence("taj"), "ㄊㄚˇ");
  XCTAssertEqual(composer.cnvSequence("tak"), "ㄊㄚˋ");
  XCTAssertEqual(composer.cnvSequence("trk"), "ㄊㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ti"), "ㄊㄞ");
  XCTAssertEqual(composer.cnvSequence("tif"), "ㄊㄞˊ");
  XCTAssertEqual(composer.cnvSequence("tij"), "ㄊㄞˇ");
  XCTAssertEqual(composer.cnvSequence("tik"), "ㄊㄞˋ");
  XCTAssertEqual(composer.cnvSequence("tid"), "ㄊㄞ˙");
  XCTAssertEqual(composer.cnvSequence("tz"), "ㄊㄠ");
  XCTAssertEqual(composer.cnvSequence("tzf"), "ㄊㄠˊ");
  XCTAssertEqual(composer.cnvSequence("tzj"), "ㄊㄠˇ");
  XCTAssertEqual(composer.cnvSequence("tzk"), "ㄊㄠˋ");
  XCTAssertEqual(composer.cnvSequence("tzd"), "ㄊㄠ˙");
  XCTAssertEqual(composer.cnvSequence("tp"), "ㄊㄡ");
  XCTAssertEqual(composer.cnvSequence("tpf"), "ㄊㄡˊ");
  XCTAssertEqual(composer.cnvSequence("tpj"), "ㄊㄡˇ");
  XCTAssertEqual(composer.cnvSequence("tpk"), "ㄊㄡˋ");
  XCTAssertEqual(composer.cnvSequence("tpd"), "ㄊㄡ˙");
  XCTAssertEqual(composer.cnvSequence("tm"), "ㄊㄢ");
  XCTAssertEqual(composer.cnvSequence("tmf"), "ㄊㄢˊ");
  XCTAssertEqual(composer.cnvSequence("tmj"), "ㄊㄢˇ");
  XCTAssertEqual(composer.cnvSequence("tmk"), "ㄊㄢˋ");
  XCTAssertEqual(composer.cnvSequence("tt"), "ㄊㄤ");
  XCTAssertEqual(composer.cnvSequence("ttf"), "ㄊㄤˊ");
  XCTAssertEqual(composer.cnvSequence("ttj"), "ㄊㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ttk"), "ㄊㄤˋ");
  XCTAssertEqual(composer.cnvSequence("tl"), "ㄊㄥ");
  XCTAssertEqual(composer.cnvSequence("tlf"), "ㄊㄥˊ");
  XCTAssertEqual(composer.cnvSequence("tlk"), "ㄊㄥˋ");
  XCTAssertEqual(composer.cnvSequence("te"), "ㄊㄧ");
  XCTAssertEqual(composer.cnvSequence("tef"), "ㄊㄧˊ");
  XCTAssertEqual(composer.cnvSequence("tej"), "ㄊㄧˇ");
  XCTAssertEqual(composer.cnvSequence("tek"), "ㄊㄧˋ");
  XCTAssertEqual(composer.cnvSequence("tew"), "ㄊㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("tewf"), "ㄊㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("tewj"), "ㄊㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("tewk"), "ㄊㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("tez"), "ㄊㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("tezf"), "ㄊㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("tezj"), "ㄊㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("tezk"), "ㄊㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("tem"), "ㄊㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("temf"), "ㄊㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("temj"), "ㄊㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("temk"), "ㄊㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("tel"), "ㄊㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("telf"), "ㄊㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("telj"), "ㄊㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("telk"), "ㄊㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("tx"), "ㄊㄨ");
  XCTAssertEqual(composer.cnvSequence("txf"), "ㄊㄨˊ");
  XCTAssertEqual(composer.cnvSequence("txj"), "ㄊㄨˇ");
  XCTAssertEqual(composer.cnvSequence("txk"), "ㄊㄨˋ");
  XCTAssertEqual(composer.cnvSequence("txo"), "ㄊㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("txof"), "ㄊㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("txoj"), "ㄊㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("txok"), "ㄊㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("txq"), "ㄊㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("txqf"), "ㄊㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("txqj"), "ㄊㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("txqk"), "ㄊㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("txm"), "ㄊㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("txmf"), "ㄊㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("txmj"), "ㄊㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("txmk"), "ㄊㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("txn"), "ㄊㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("txnf"), "ㄊㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("txnj"), "ㄊㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("txnk"), "ㄊㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("txl"), "ㄊㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("txlf"), "ㄊㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("txlj"), "ㄊㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("txlk"), "ㄊㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("na"), "ㄋㄚ");
  XCTAssertEqual(composer.cnvSequence("naf"), "ㄋㄚˊ");
  XCTAssertEqual(composer.cnvSequence("naj"), "ㄋㄚˇ");
  XCTAssertEqual(composer.cnvSequence("nak"), "ㄋㄚˋ");
  XCTAssertEqual(composer.cnvSequence("nad"), "ㄋㄚ˙");
  XCTAssertEqual(composer.cnvSequence("nrk"), "ㄋㄜˋ");
  XCTAssertEqual(composer.cnvSequence("nrd"), "ㄋㄜ˙");
  XCTAssertEqual(composer.cnvSequence("nif"), "ㄋㄞˊ");
  XCTAssertEqual(composer.cnvSequence("nij"), "ㄋㄞˇ");
  XCTAssertEqual(composer.cnvSequence("nik"), "ㄋㄞˋ");
  XCTAssertEqual(composer.cnvSequence("nqf"), "ㄋㄟˊ");
  XCTAssertEqual(composer.cnvSequence("nqj"), "ㄋㄟˇ");
  XCTAssertEqual(composer.cnvSequence("nqk"), "ㄋㄟˋ");
  XCTAssertEqual(composer.cnvSequence("nz"), "ㄋㄠ");
  XCTAssertEqual(composer.cnvSequence("nzf"), "ㄋㄠˊ");
  XCTAssertEqual(composer.cnvSequence("nzj"), "ㄋㄠˇ");
  XCTAssertEqual(composer.cnvSequence("nzk"), "ㄋㄠˋ");
  XCTAssertEqual(composer.cnvSequence("npf"), "ㄋㄡˊ");
  XCTAssertEqual(composer.cnvSequence("npj"), "ㄋㄡˇ");
  XCTAssertEqual(composer.cnvSequence("npk"), "ㄋㄡˋ");
  XCTAssertEqual(composer.cnvSequence("nm"), "ㄋㄢ");
  XCTAssertEqual(composer.cnvSequence("nmf"), "ㄋㄢˊ");
  XCTAssertEqual(composer.cnvSequence("nmj"), "ㄋㄢˇ");
  XCTAssertEqual(composer.cnvSequence("nmk"), "ㄋㄢˋ");
  XCTAssertEqual(composer.cnvSequence("nnj"), "ㄋㄣˇ");
  XCTAssertEqual(composer.cnvSequence("nnk"), "ㄋㄣˋ");
  XCTAssertEqual(composer.cnvSequence("nt"), "ㄋㄤ");
  XCTAssertEqual(composer.cnvSequence("ntf"), "ㄋㄤˊ");
  XCTAssertEqual(composer.cnvSequence("ntj"), "ㄋㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ntk"), "ㄋㄤˋ");
  XCTAssertEqual(composer.cnvSequence("ntd"), "ㄋㄤ˙");
  XCTAssertEqual(composer.cnvSequence("nlf"), "ㄋㄥˊ");
  XCTAssertEqual(composer.cnvSequence("nlj"), "ㄋㄥˇ");
  XCTAssertEqual(composer.cnvSequence("ne"), "ㄋㄧ");
  XCTAssertEqual(composer.cnvSequence("nef"), "ㄋㄧˊ");
  XCTAssertEqual(composer.cnvSequence("nej"), "ㄋㄧˇ");
  XCTAssertEqual(composer.cnvSequence("nek"), "ㄋㄧˋ");
  XCTAssertEqual(composer.cnvSequence("new"), "ㄋㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("newf"), "ㄋㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("newk"), "ㄋㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("nezj"), "ㄋㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("nezk"), "ㄋㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("nep"), "ㄋㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("nepf"), "ㄋㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("nepj"), "ㄋㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("nepk"), "ㄋㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("nem"), "ㄋㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("nemf"), "ㄋㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("nemj"), "ㄋㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("nemk"), "ㄋㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("nen"), "ㄋㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("nenf"), "ㄋㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("nenj"), "ㄋㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("nenk"), "ㄋㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("netf"), "ㄋㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("netj"), "ㄋㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("netk"), "ㄋㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("nelf"), "ㄋㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("nelj"), "ㄋㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("nelk"), "ㄋㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("nxf"), "ㄋㄨˊ");
  XCTAssertEqual(composer.cnvSequence("nxj"), "ㄋㄨˇ");
  XCTAssertEqual(composer.cnvSequence("nxk"), "ㄋㄨˋ");
  XCTAssertEqual(composer.cnvSequence("nxof"), "ㄋㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("nxoj"), "ㄋㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("nxok"), "ㄋㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("nxqf"), "ㄋㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("nxmf"), "ㄋㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("nxmj"), "ㄋㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("nxmk"), "ㄋㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("nxnf"), "ㄋㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("nxlf"), "ㄋㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("nxlj"), "ㄋㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("nxlk"), "ㄋㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("nuf"), "ㄋㄩˊ");
  XCTAssertEqual(composer.cnvSequence("nuj"), "ㄋㄩˇ");
  XCTAssertEqual(composer.cnvSequence("nuk"), "ㄋㄩˋ");
  XCTAssertEqual(composer.cnvSequence("nuwk"), "ㄋㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("la"), "ㄌㄚ");
  XCTAssertEqual(composer.cnvSequence("laf"), "ㄌㄚˊ");
  XCTAssertEqual(composer.cnvSequence("laj"), "ㄌㄚˇ");
  XCTAssertEqual(composer.cnvSequence("lak"), "ㄌㄚˋ");
  XCTAssertEqual(composer.cnvSequence("lad"), "ㄌㄚ˙");
  XCTAssertEqual(composer.cnvSequence("lo"), "ㄌㄛ");
  XCTAssertEqual(composer.cnvSequence("lod"), "ㄌㄛ˙");
  XCTAssertEqual(composer.cnvSequence("lr"), "ㄌㄜ");
  XCTAssertEqual(composer.cnvSequence("lrf"), "ㄌㄜˊ");
  XCTAssertEqual(composer.cnvSequence("lrk"), "ㄌㄜˋ");
  XCTAssertEqual(composer.cnvSequence("lrd"), "ㄌㄜ˙");
  XCTAssertEqual(composer.cnvSequence("lif"), "ㄌㄞˊ");
  XCTAssertEqual(composer.cnvSequence("lij"), "ㄌㄞˇ");
  XCTAssertEqual(composer.cnvSequence("lik"), "ㄌㄞˋ");
  XCTAssertEqual(composer.cnvSequence("lq"), "ㄌㄟ");
  XCTAssertEqual(composer.cnvSequence("lqf"), "ㄌㄟˊ");
  XCTAssertEqual(composer.cnvSequence("lqj"), "ㄌㄟˇ");
  XCTAssertEqual(composer.cnvSequence("lqk"), "ㄌㄟˋ");
  XCTAssertEqual(composer.cnvSequence("lqd"), "ㄌㄟ˙");
  XCTAssertEqual(composer.cnvSequence("lz"), "ㄌㄠ");
  XCTAssertEqual(composer.cnvSequence("lzf"), "ㄌㄠˊ");
  XCTAssertEqual(composer.cnvSequence("lzj"), "ㄌㄠˇ");
  XCTAssertEqual(composer.cnvSequence("lzk"), "ㄌㄠˋ");
  XCTAssertEqual(composer.cnvSequence("lp"), "ㄌㄡ");
  XCTAssertEqual(composer.cnvSequence("lpf"), "ㄌㄡˊ");
  XCTAssertEqual(composer.cnvSequence("lpj"), "ㄌㄡˇ");
  XCTAssertEqual(composer.cnvSequence("lpk"), "ㄌㄡˋ");
  XCTAssertEqual(composer.cnvSequence("lpd"), "ㄌㄡ˙");
  XCTAssertEqual(composer.cnvSequence("lmf"), "ㄌㄢˊ");
  XCTAssertEqual(composer.cnvSequence("lmj"), "ㄌㄢˇ");
  XCTAssertEqual(composer.cnvSequence("lmk"), "ㄌㄢˋ");
  XCTAssertEqual(composer.cnvSequence("lt"), "ㄌㄤ");
  XCTAssertEqual(composer.cnvSequence("ltf"), "ㄌㄤˊ");
  XCTAssertEqual(composer.cnvSequence("ltj"), "ㄌㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ltk"), "ㄌㄤˋ");
  XCTAssertEqual(composer.cnvSequence("ll"), "ㄌㄥ");
  XCTAssertEqual(composer.cnvSequence("llf"), "ㄌㄥˊ");
  XCTAssertEqual(composer.cnvSequence("llj"), "ㄌㄥˇ");
  XCTAssertEqual(composer.cnvSequence("llk"), "ㄌㄥˋ");
  XCTAssertEqual(composer.cnvSequence("le"), "ㄌㄧ");
  XCTAssertEqual(composer.cnvSequence("lef"), "ㄌㄧˊ");
  XCTAssertEqual(composer.cnvSequence("lej"), "ㄌㄧˇ");
  XCTAssertEqual(composer.cnvSequence("lek"), "ㄌㄧˋ");
  XCTAssertEqual(composer.cnvSequence("led"), "ㄌㄧ˙");
  XCTAssertEqual(composer.cnvSequence("leaj"), "ㄌㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("lew"), "ㄌㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("lewf"), "ㄌㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("lewj"), "ㄌㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("lewk"), "ㄌㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("lez"), "ㄌㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("lezf"), "ㄌㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("lezj"), "ㄌㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("lezk"), "ㄌㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("lep"), "ㄌㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("lepf"), "ㄌㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("lepj"), "ㄌㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("lepk"), "ㄌㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("lem"), "ㄌㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("lemf"), "ㄌㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("lemj"), "ㄌㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("lemk"), "ㄌㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("lenf"), "ㄌㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("lenj"), "ㄌㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("lenk"), "ㄌㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("letf"), "ㄌㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("letj"), "ㄌㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("letk"), "ㄌㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("lel"), "ㄌㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("lelf"), "ㄌㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("lelj"), "ㄌㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("lelk"), "ㄌㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("lx"), "ㄌㄨ");
  XCTAssertEqual(composer.cnvSequence("lxf"), "ㄌㄨˊ");
  XCTAssertEqual(composer.cnvSequence("lxj"), "ㄌㄨˇ");
  XCTAssertEqual(composer.cnvSequence("lxk"), "ㄌㄨˋ");
  XCTAssertEqual(composer.cnvSequence("lxo"), "ㄌㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("lxof"), "ㄌㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("lxoj"), "ㄌㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("lxok"), "ㄌㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("lxod"), "ㄌㄨㄛ˙");
  XCTAssertEqual(composer.cnvSequence("lxmf"), "ㄌㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("lxmj"), "ㄌㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("lxmk"), "ㄌㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("lxn"), "ㄌㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("lxnf"), "ㄌㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("lxnj"), "ㄌㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("lxnk"), "ㄌㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("lxl"), "ㄌㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("lxlf"), "ㄌㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("lxlj"), "ㄌㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("lxlk"), "ㄌㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("lu"), "ㄌㄩ");
  XCTAssertEqual(composer.cnvSequence("luf"), "ㄌㄩˊ");
  XCTAssertEqual(composer.cnvSequence("luj"), "ㄌㄩˇ");
  XCTAssertEqual(composer.cnvSequence("luk"), "ㄌㄩˋ");
  XCTAssertEqual(composer.cnvSequence("luw"), "ㄌㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("luwj"), "ㄌㄩㄝˇ");
  XCTAssertEqual(composer.cnvSequence("luwk"), "ㄌㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("lumf"), "ㄌㄩㄢˊ");
  XCTAssertEqual(composer.cnvSequence("lumj"), "ㄌㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("va"), "ㄍㄚ");
  XCTAssertEqual(composer.cnvSequence("vaf"), "ㄍㄚˊ");
  XCTAssertEqual(composer.cnvSequence("vaj"), "ㄍㄚˇ");
  XCTAssertEqual(composer.cnvSequence("vak"), "ㄍㄚˋ");
  XCTAssertEqual(composer.cnvSequence("vad"), "ㄍㄚ˙");
  XCTAssertEqual(composer.cnvSequence("vr"), "ㄍㄜ");
  XCTAssertEqual(composer.cnvSequence("vrf"), "ㄍㄜˊ");
  XCTAssertEqual(composer.cnvSequence("vrj"), "ㄍㄜˇ");
  XCTAssertEqual(composer.cnvSequence("vrk"), "ㄍㄜˋ");
  XCTAssertEqual(composer.cnvSequence("vrd"), "ㄍㄜ˙");
  XCTAssertEqual(composer.cnvSequence("vi"), "ㄍㄞ");
  XCTAssertEqual(composer.cnvSequence("vij"), "ㄍㄞˇ");
  XCTAssertEqual(composer.cnvSequence("vik"), "ㄍㄞˋ");
  XCTAssertEqual(composer.cnvSequence("vqj"), "ㄍㄟˇ");
  XCTAssertEqual(composer.cnvSequence("vz"), "ㄍㄠ");
  XCTAssertEqual(composer.cnvSequence("vzj"), "ㄍㄠˇ");
  XCTAssertEqual(composer.cnvSequence("vzk"), "ㄍㄠˋ");
  XCTAssertEqual(composer.cnvSequence("vp"), "ㄍㄡ");
  XCTAssertEqual(composer.cnvSequence("vpj"), "ㄍㄡˇ");
  XCTAssertEqual(composer.cnvSequence("vpk"), "ㄍㄡˋ");
  XCTAssertEqual(composer.cnvSequence("vm"), "ㄍㄢ");
  XCTAssertEqual(composer.cnvSequence("vmj"), "ㄍㄢˇ");
  XCTAssertEqual(composer.cnvSequence("vmk"), "ㄍㄢˋ");
  XCTAssertEqual(composer.cnvSequence("vn"), "ㄍㄣ");
  XCTAssertEqual(composer.cnvSequence("vnf"), "ㄍㄣˊ");
  XCTAssertEqual(composer.cnvSequence("vnj"), "ㄍㄣˇ");
  XCTAssertEqual(composer.cnvSequence("vnk"), "ㄍㄣˋ");
  XCTAssertEqual(composer.cnvSequence("vt"), "ㄍㄤ");
  XCTAssertEqual(composer.cnvSequence("vtj"), "ㄍㄤˇ");
  XCTAssertEqual(composer.cnvSequence("vtk"), "ㄍㄤˋ");
  XCTAssertEqual(composer.cnvSequence("vl"), "ㄍㄥ");
  XCTAssertEqual(composer.cnvSequence("vlj"), "ㄍㄥˇ");
  XCTAssertEqual(composer.cnvSequence("vlk"), "ㄍㄥˋ");
  XCTAssertEqual(composer.cnvSequence("vx"), "ㄍㄨ");
  XCTAssertEqual(composer.cnvSequence("vxf"), "ㄍㄨˊ");
  XCTAssertEqual(composer.cnvSequence("vxj"), "ㄍㄨˇ");
  XCTAssertEqual(composer.cnvSequence("vxk"), "ㄍㄨˋ");
  XCTAssertEqual(composer.cnvSequence("vxa"), "ㄍㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("vxaf"), "ㄍㄨㄚˊ");
  XCTAssertEqual(composer.cnvSequence("vxaj"), "ㄍㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("vxak"), "ㄍㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("vxo"), "ㄍㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("vxof"), "ㄍㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("vxoj"), "ㄍㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("vxok"), "ㄍㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("vxrf"), "ㄍㄨㄜˊ");
  XCTAssertEqual(composer.cnvSequence("vxi"), "ㄍㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("vxij"), "ㄍㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("vxik"), "ㄍㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("vxq"), "ㄍㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("vxqj"), "ㄍㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("vxqk"), "ㄍㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("vxm"), "ㄍㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("vxmj"), "ㄍㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("vxmk"), "ㄍㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("vxn"), "ㄍㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("vxnj"), "ㄍㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("vxnk"), "ㄍㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("vxt"), "ㄍㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("vxtj"), "ㄍㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("vxtk"), "ㄍㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("vxl"), "ㄍㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("vxlf"), "ㄍㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("vxlj"), "ㄍㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("vxlk"), "ㄍㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ka"), "ㄎㄚ");
  XCTAssertEqual(composer.cnvSequence("kaj"), "ㄎㄚˇ");
  XCTAssertEqual(composer.cnvSequence("kak"), "ㄎㄚˋ");
  XCTAssertEqual(composer.cnvSequence("kr"), "ㄎㄜ");
  XCTAssertEqual(composer.cnvSequence("krf"), "ㄎㄜˊ");
  XCTAssertEqual(composer.cnvSequence("krj"), "ㄎㄜˇ");
  XCTAssertEqual(composer.cnvSequence("krk"), "ㄎㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ki"), "ㄎㄞ");
  XCTAssertEqual(composer.cnvSequence("kij"), "ㄎㄞˇ");
  XCTAssertEqual(composer.cnvSequence("kik"), "ㄎㄞˋ");
  XCTAssertEqual(composer.cnvSequence("kz"), "ㄎㄠ");
  XCTAssertEqual(composer.cnvSequence("kzj"), "ㄎㄠˇ");
  XCTAssertEqual(composer.cnvSequence("kzk"), "ㄎㄠˋ");
  XCTAssertEqual(composer.cnvSequence("kp"), "ㄎㄡ");
  XCTAssertEqual(composer.cnvSequence("kpj"), "ㄎㄡˇ");
  XCTAssertEqual(composer.cnvSequence("kpk"), "ㄎㄡˋ");
  XCTAssertEqual(composer.cnvSequence("km"), "ㄎㄢ");
  XCTAssertEqual(composer.cnvSequence("kmj"), "ㄎㄢˇ");
  XCTAssertEqual(composer.cnvSequence("kmk"), "ㄎㄢˋ");
  XCTAssertEqual(composer.cnvSequence("kn"), "ㄎㄣ");
  XCTAssertEqual(composer.cnvSequence("knj"), "ㄎㄣˇ");
  XCTAssertEqual(composer.cnvSequence("knk"), "ㄎㄣˋ");
  XCTAssertEqual(composer.cnvSequence("kt"), "ㄎㄤ");
  XCTAssertEqual(composer.cnvSequence("ktf"), "ㄎㄤˊ");
  XCTAssertEqual(composer.cnvSequence("ktj"), "ㄎㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ktk"), "ㄎㄤˋ");
  XCTAssertEqual(composer.cnvSequence("kl"), "ㄎㄥ");
  XCTAssertEqual(composer.cnvSequence("klj"), "ㄎㄥˇ");
  XCTAssertEqual(composer.cnvSequence("kx"), "ㄎㄨ");
  XCTAssertEqual(composer.cnvSequence("kxf"), "ㄎㄨˊ");
  XCTAssertEqual(composer.cnvSequence("kxj"), "ㄎㄨˇ");
  XCTAssertEqual(composer.cnvSequence("kxk"), "ㄎㄨˋ");
  XCTAssertEqual(composer.cnvSequence("kxa"), "ㄎㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("kxaj"), "ㄎㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("kxak"), "ㄎㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("kxok"), "ㄎㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("kxi"), "ㄎㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("kxij"), "ㄎㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("kxik"), "ㄎㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("kxq"), "ㄎㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("kxqf"), "ㄎㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("kxqj"), "ㄎㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("kxqk"), "ㄎㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("kxm"), "ㄎㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("kxmj"), "ㄎㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("kxmk"), "ㄎㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("kxn"), "ㄎㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("kxnj"), "ㄎㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("kxnk"), "ㄎㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("kxt"), "ㄎㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("kxtf"), "ㄎㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("kxtj"), "ㄎㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("kxtk"), "ㄎㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("kxl"), "ㄎㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("kxlj"), "ㄎㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("kxlk"), "ㄎㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ha"), "ㄏㄚ");
  XCTAssertEqual(composer.cnvSequence("haf"), "ㄏㄚˊ");
  XCTAssertEqual(composer.cnvSequence("haj"), "ㄏㄚˇ");
  XCTAssertEqual(composer.cnvSequence("hr"), "ㄏㄜ");
  XCTAssertEqual(composer.cnvSequence("hrf"), "ㄏㄜˊ");
  XCTAssertEqual(composer.cnvSequence("hrj"), "ㄏㄜˇ");
  XCTAssertEqual(composer.cnvSequence("hrk"), "ㄏㄜˋ");
  XCTAssertEqual(composer.cnvSequence("hi"), "ㄏㄞ");
  XCTAssertEqual(composer.cnvSequence("hif"), "ㄏㄞˊ");
  XCTAssertEqual(composer.cnvSequence("hij"), "ㄏㄞˇ");
  XCTAssertEqual(composer.cnvSequence("hik"), "ㄏㄞˋ");
  XCTAssertEqual(composer.cnvSequence("hq"), "ㄏㄟ");
  XCTAssertEqual(composer.cnvSequence("hqj"), "ㄏㄟˇ");
  XCTAssertEqual(composer.cnvSequence("hz"), "ㄏㄠ");
  XCTAssertEqual(composer.cnvSequence("hzf"), "ㄏㄠˊ");
  XCTAssertEqual(composer.cnvSequence("hzj"), "ㄏㄠˇ");
  XCTAssertEqual(composer.cnvSequence("hzk"), "ㄏㄠˋ");
  XCTAssertEqual(composer.cnvSequence("hp"), "ㄏㄡ");
  XCTAssertEqual(composer.cnvSequence("hpf"), "ㄏㄡˊ");
  XCTAssertEqual(composer.cnvSequence("hpj"), "ㄏㄡˇ");
  XCTAssertEqual(composer.cnvSequence("hpk"), "ㄏㄡˋ");
  XCTAssertEqual(composer.cnvSequence("hm"), "ㄏㄢ");
  XCTAssertEqual(composer.cnvSequence("hmf"), "ㄏㄢˊ");
  XCTAssertEqual(composer.cnvSequence("hmj"), "ㄏㄢˇ");
  XCTAssertEqual(composer.cnvSequence("hmk"), "ㄏㄢˋ");
  XCTAssertEqual(composer.cnvSequence("hn"), "ㄏㄣ");
  XCTAssertEqual(composer.cnvSequence("hnf"), "ㄏㄣˊ");
  XCTAssertEqual(composer.cnvSequence("hnj"), "ㄏㄣˇ");
  XCTAssertEqual(composer.cnvSequence("hnk"), "ㄏㄣˋ");
  XCTAssertEqual(composer.cnvSequence("ht"), "ㄏㄤ");
  XCTAssertEqual(composer.cnvSequence("htf"), "ㄏㄤˊ");
  XCTAssertEqual(composer.cnvSequence("htj"), "ㄏㄤˇ");
  XCTAssertEqual(composer.cnvSequence("htk"), "ㄏㄤˋ");
  XCTAssertEqual(composer.cnvSequence("hl"), "ㄏㄥ");
  XCTAssertEqual(composer.cnvSequence("hlf"), "ㄏㄥˊ");
  XCTAssertEqual(composer.cnvSequence("hlk"), "ㄏㄥˋ");
  XCTAssertEqual(composer.cnvSequence("hx"), "ㄏㄨ");
  XCTAssertEqual(composer.cnvSequence("hxf"), "ㄏㄨˊ");
  XCTAssertEqual(composer.cnvSequence("hxj"), "ㄏㄨˇ");
  XCTAssertEqual(composer.cnvSequence("hxk"), "ㄏㄨˋ");
  XCTAssertEqual(composer.cnvSequence("hxa"), "ㄏㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("hxaf"), "ㄏㄨㄚˊ");
  XCTAssertEqual(composer.cnvSequence("hxaj"), "ㄏㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("hxak"), "ㄏㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("hxo"), "ㄏㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("hxof"), "ㄏㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("hxoj"), "ㄏㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("hxok"), "ㄏㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("hxod"), "ㄏㄨㄛ˙");
  XCTAssertEqual(composer.cnvSequence("hxif"), "ㄏㄨㄞˊ");
  XCTAssertEqual(composer.cnvSequence("hxik"), "ㄏㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("hxq"), "ㄏㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("hxqf"), "ㄏㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("hxqj"), "ㄏㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("hxqk"), "ㄏㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("hxm"), "ㄏㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("hxmf"), "ㄏㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("hxmj"), "ㄏㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("hxmk"), "ㄏㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("hxn"), "ㄏㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("hxnf"), "ㄏㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("hxnj"), "ㄏㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("hxnk"), "ㄏㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("hxt"), "ㄏㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("hxtf"), "ㄏㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("hxtj"), "ㄏㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("hxtk"), "ㄏㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("hxtd"), "ㄏㄨㄤ˙");
  XCTAssertEqual(composer.cnvSequence("hxl"), "ㄏㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("hxlf"), "ㄏㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("hxlj"), "ㄏㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("hxlk"), "ㄏㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ge"), "ㄐㄧ");
  XCTAssertEqual(composer.cnvSequence("gef"), "ㄐㄧˊ");
  XCTAssertEqual(composer.cnvSequence("gej"), "ㄐㄧˇ");
  XCTAssertEqual(composer.cnvSequence("gek"), "ㄐㄧˋ");
  XCTAssertEqual(composer.cnvSequence("gea"), "ㄐㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("geaf"), "ㄐㄧㄚˊ");
  XCTAssertEqual(composer.cnvSequence("geaj"), "ㄐㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("geak"), "ㄐㄧㄚˋ");
  XCTAssertEqual(composer.cnvSequence("gew"), "ㄐㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("gewf"), "ㄐㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("gewj"), "ㄐㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("gewk"), "ㄐㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("gewd"), "ㄐㄧㄝ˙");
  XCTAssertEqual(composer.cnvSequence("gez"), "ㄐㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("gezf"), "ㄐㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("gezj"), "ㄐㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("gezk"), "ㄐㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("gep"), "ㄐㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("gepj"), "ㄐㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("gepk"), "ㄐㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("gem"), "ㄐㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("gemj"), "ㄐㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("gemk"), "ㄐㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("gen"), "ㄐㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("genj"), "ㄐㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("genk"), "ㄐㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("get"), "ㄐㄧㄤ");
  XCTAssertEqual(composer.cnvSequence("getf"), "ㄐㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("getj"), "ㄐㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("getk"), "ㄐㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("gel"), "ㄐㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("gelj"), "ㄐㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("gelk"), "ㄐㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("gu"), "ㄐㄩ");
  XCTAssertEqual(composer.cnvSequence("guf"), "ㄐㄩˊ");
  XCTAssertEqual(composer.cnvSequence("guj"), "ㄐㄩˇ");
  XCTAssertEqual(composer.cnvSequence("guk"), "ㄐㄩˋ");
  XCTAssertEqual(composer.cnvSequence("guw"), "ㄐㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("guwf"), "ㄐㄩㄝˊ");
  XCTAssertEqual(composer.cnvSequence("guwj"), "ㄐㄩㄝˇ");
  XCTAssertEqual(composer.cnvSequence("guwk"), "ㄐㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("gum"), "ㄐㄩㄢ");
  XCTAssertEqual(composer.cnvSequence("gumj"), "ㄐㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("gumk"), "ㄐㄩㄢˋ");
  XCTAssertEqual(composer.cnvSequence("gun"), "ㄐㄩㄣ");
  XCTAssertEqual(composer.cnvSequence("gunf"), "ㄐㄩㄣˊ");
  XCTAssertEqual(composer.cnvSequence("gunj"), "ㄐㄩㄣˇ");
  XCTAssertEqual(composer.cnvSequence("gunk"), "ㄐㄩㄣˋ");
  XCTAssertEqual(composer.cnvSequence("gul"), "ㄐㄩㄥ");
  XCTAssertEqual(composer.cnvSequence("gulj"), "ㄐㄩㄥˇ");
  XCTAssertEqual(composer.cnvSequence("gulk"), "ㄐㄩㄥˋ");
  // XCTAssertEqual(composer.cnvSequence("vd"), "ㄑ˙");
  XCTAssertEqual(composer.cnvSequence("ve"), "ㄑㄧ");
  XCTAssertEqual(composer.cnvSequence("vef"), "ㄑㄧˊ");
  XCTAssertEqual(composer.cnvSequence("vej"), "ㄑㄧˇ");
  XCTAssertEqual(composer.cnvSequence("vek"), "ㄑㄧˋ");
  XCTAssertEqual(composer.cnvSequence("vea"), "ㄑㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("veaf"), "ㄑㄧㄚˊ");
  XCTAssertEqual(composer.cnvSequence("veaj"), "ㄑㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("veak"), "ㄑㄧㄚˋ");
  XCTAssertEqual(composer.cnvSequence("vew"), "ㄑㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("vewf"), "ㄑㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("vewj"), "ㄑㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("vewk"), "ㄑㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("vez"), "ㄑㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("vezf"), "ㄑㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("vezj"), "ㄑㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("vezk"), "ㄑㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("vep"), "ㄑㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("vepf"), "ㄑㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("vepj"), "ㄑㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("vepk"), "ㄑㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("vem"), "ㄑㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("vemf"), "ㄑㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("vemj"), "ㄑㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("vemk"), "ㄑㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("ven"), "ㄑㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("venf"), "ㄑㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("venj"), "ㄑㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("venk"), "ㄑㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("vet"), "ㄑㄧㄤ");
  XCTAssertEqual(composer.cnvSequence("vetf"), "ㄑㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("vetj"), "ㄑㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("vetk"), "ㄑㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("vel"), "ㄑㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("velf"), "ㄑㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("velj"), "ㄑㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("velk"), "ㄑㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("vu"), "ㄑㄩ");
  XCTAssertEqual(composer.cnvSequence("vuf"), "ㄑㄩˊ");
  XCTAssertEqual(composer.cnvSequence("vuj"), "ㄑㄩˇ");
  XCTAssertEqual(composer.cnvSequence("vuk"), "ㄑㄩˋ");
  XCTAssertEqual(composer.cnvSequence("vuw"), "ㄑㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("vuwf"), "ㄑㄩㄝˊ");
  XCTAssertEqual(composer.cnvSequence("vuwk"), "ㄑㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("vum"), "ㄑㄩㄢ");
  XCTAssertEqual(composer.cnvSequence("vumf"), "ㄑㄩㄢˊ");
  XCTAssertEqual(composer.cnvSequence("vumj"), "ㄑㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("vumk"), "ㄑㄩㄢˋ");
  XCTAssertEqual(composer.cnvSequence("vun"), "ㄑㄩㄣ");
  XCTAssertEqual(composer.cnvSequence("vunf"), "ㄑㄩㄣˊ");
  XCTAssertEqual(composer.cnvSequence("vunj"), "ㄑㄩㄣˇ");
  XCTAssertEqual(composer.cnvSequence("vunk"), "ㄑㄩㄣˋ");
  XCTAssertEqual(composer.cnvSequence("vul"), "ㄑㄩㄥ");
  XCTAssertEqual(composer.cnvSequence("vulf"), "ㄑㄩㄥˊ");
  XCTAssertEqual(composer.cnvSequence("vulj"), "ㄑㄩㄥˇ");
  XCTAssertEqual(composer.cnvSequence("vulk"), "ㄑㄩㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ce"), "ㄒㄧ");
  XCTAssertEqual(composer.cnvSequence("cef"), "ㄒㄧˊ");
  XCTAssertEqual(composer.cnvSequence("cej"), "ㄒㄧˇ");
  XCTAssertEqual(composer.cnvSequence("cek"), "ㄒㄧˋ");
  XCTAssertEqual(composer.cnvSequence("cea"), "ㄒㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("ceaf"), "ㄒㄧㄚˊ");
  XCTAssertEqual(composer.cnvSequence("ceaj"), "ㄒㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("ceak"), "ㄒㄧㄚˋ");
  XCTAssertEqual(composer.cnvSequence("cew"), "ㄒㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("cewf"), "ㄒㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("cewj"), "ㄒㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("cewk"), "ㄒㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("cez"), "ㄒㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("cezf"), "ㄒㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("cezj"), "ㄒㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("cezk"), "ㄒㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("cep"), "ㄒㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("cepf"), "ㄒㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("cepj"), "ㄒㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("cepk"), "ㄒㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("cem"), "ㄒㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("cemf"), "ㄒㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("cemj"), "ㄒㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("cemk"), "ㄒㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("cen"), "ㄒㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("cenf"), "ㄒㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("cenj"), "ㄒㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("cenk"), "ㄒㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("cet"), "ㄒㄧㄤ");
  XCTAssertEqual(composer.cnvSequence("cetf"), "ㄒㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("cetj"), "ㄒㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("cetk"), "ㄒㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("cel"), "ㄒㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("celf"), "ㄒㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("celj"), "ㄒㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("celk"), "ㄒㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("cu"), "ㄒㄩ");
  XCTAssertEqual(composer.cnvSequence("cuf"), "ㄒㄩˊ");
  XCTAssertEqual(composer.cnvSequence("cuj"), "ㄒㄩˇ");
  XCTAssertEqual(composer.cnvSequence("cuk"), "ㄒㄩˋ");
  XCTAssertEqual(composer.cnvSequence("cuw"), "ㄒㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("cuwf"), "ㄒㄩㄝˊ");
  XCTAssertEqual(composer.cnvSequence("cuwj"), "ㄒㄩㄝˇ");
  XCTAssertEqual(composer.cnvSequence("cuwk"), "ㄒㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("cum"), "ㄒㄩㄢ");
  XCTAssertEqual(composer.cnvSequence("cumf"), "ㄒㄩㄢˊ");
  XCTAssertEqual(composer.cnvSequence("cumj"), "ㄒㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("cumk"), "ㄒㄩㄢˋ");
  XCTAssertEqual(composer.cnvSequence("cun"), "ㄒㄩㄣ");
  XCTAssertEqual(composer.cnvSequence("cunf"), "ㄒㄩㄣˊ");
  XCTAssertEqual(composer.cnvSequence("cunk"), "ㄒㄩㄣˋ");
  XCTAssertEqual(composer.cnvSequence("cul"), "ㄒㄩㄥ");
  XCTAssertEqual(composer.cnvSequence("culf"), "ㄒㄩㄥˊ");
  XCTAssertEqual(composer.cnvSequence("culj"), "ㄒㄩㄥˇ");
  XCTAssertEqual(composer.cnvSequence("culk"), "ㄒㄩㄥˋ");
  XCTAssertEqual(composer.cnvSequence("g"), "ㄓ");
  XCTAssertEqual(composer.cnvSequence("gf"), "ㄓˊ");
  XCTAssertEqual(composer.cnvSequence("gj"), "ㄓˇ");
  XCTAssertEqual(composer.cnvSequence("gk"), "ㄓˋ");
  XCTAssertEqual(composer.cnvSequence("ga"), "ㄓㄚ");
  XCTAssertEqual(composer.cnvSequence("gaf"), "ㄓㄚˊ");
  XCTAssertEqual(composer.cnvSequence("gaj"), "ㄓㄚˇ");
  XCTAssertEqual(composer.cnvSequence("gak"), "ㄓㄚˋ");
  XCTAssertEqual(composer.cnvSequence("gr"), "ㄓㄜ");
  XCTAssertEqual(composer.cnvSequence("grf"), "ㄓㄜˊ");
  XCTAssertEqual(composer.cnvSequence("grj"), "ㄓㄜˇ");
  XCTAssertEqual(composer.cnvSequence("grk"), "ㄓㄜˋ");
  XCTAssertEqual(composer.cnvSequence("grd"), "ㄓㄜ˙");
  XCTAssertEqual(composer.cnvSequence("gi"), "ㄓㄞ");
  XCTAssertEqual(composer.cnvSequence("gif"), "ㄓㄞˊ");
  XCTAssertEqual(composer.cnvSequence("gij"), "ㄓㄞˇ");
  XCTAssertEqual(composer.cnvSequence("gik"), "ㄓㄞˋ");
  XCTAssertEqual(composer.cnvSequence("gqk"), "ㄓㄟˋ");
  XCTAssertEqual(composer.cnvSequence("gz"), "ㄓㄠ");
  XCTAssertEqual(composer.cnvSequence("gzf"), "ㄓㄠˊ");
  XCTAssertEqual(composer.cnvSequence("gzj"), "ㄓㄠˇ");
  XCTAssertEqual(composer.cnvSequence("gzk"), "ㄓㄠˋ");
  XCTAssertEqual(composer.cnvSequence("gp"), "ㄓㄡ");
  XCTAssertEqual(composer.cnvSequence("gpf"), "ㄓㄡˊ");
  XCTAssertEqual(composer.cnvSequence("gpj"), "ㄓㄡˇ");
  XCTAssertEqual(composer.cnvSequence("gpk"), "ㄓㄡˋ");
  XCTAssertEqual(composer.cnvSequence("gm"), "ㄓㄢ");
  XCTAssertEqual(composer.cnvSequence("gmj"), "ㄓㄢˇ");
  XCTAssertEqual(composer.cnvSequence("gmk"), "ㄓㄢˋ");
  XCTAssertEqual(composer.cnvSequence("gn"), "ㄓㄣ");
  XCTAssertEqual(composer.cnvSequence("gnf"), "ㄓㄣˊ");
  XCTAssertEqual(composer.cnvSequence("gnj"), "ㄓㄣˇ");
  XCTAssertEqual(composer.cnvSequence("gnk"), "ㄓㄣˋ");
  XCTAssertEqual(composer.cnvSequence("gt"), "ㄓㄤ");
  XCTAssertEqual(composer.cnvSequence("gtj"), "ㄓㄤˇ");
  XCTAssertEqual(composer.cnvSequence("gtk"), "ㄓㄤˋ");
  XCTAssertEqual(composer.cnvSequence("gl"), "ㄓㄥ");
  XCTAssertEqual(composer.cnvSequence("glj"), "ㄓㄥˇ");
  XCTAssertEqual(composer.cnvSequence("glk"), "ㄓㄥˋ");
  XCTAssertEqual(composer.cnvSequence("gx"), "ㄓㄨ");
  XCTAssertEqual(composer.cnvSequence("gxf"), "ㄓㄨˊ");
  XCTAssertEqual(composer.cnvSequence("gxj"), "ㄓㄨˇ");
  XCTAssertEqual(composer.cnvSequence("gxk"), "ㄓㄨˋ");
  XCTAssertEqual(composer.cnvSequence("gxa"), "ㄓㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("gxaj"), "ㄓㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("gxo"), "ㄓㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("gxof"), "ㄓㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("gxok"), "ㄓㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("gxi"), "ㄓㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("gxij"), "ㄓㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("gxik"), "ㄓㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("gxq"), "ㄓㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("gxqj"), "ㄓㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("gxqk"), "ㄓㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("gxm"), "ㄓㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("gxmj"), "ㄓㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("gxmk"), "ㄓㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("gxn"), "ㄓㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("gxnj"), "ㄓㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("gxnk"), "ㄓㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("gxt"), "ㄓㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("gxtj"), "ㄓㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("gxtk"), "ㄓㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("gxl"), "ㄓㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("gxlj"), "ㄓㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("gxlk"), "ㄓㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("y"), "ㄔ");
  XCTAssertEqual(composer.cnvSequence("yf"), "ㄔˊ");
  XCTAssertEqual(composer.cnvSequence("yj"), "ㄔˇ");
  XCTAssertEqual(composer.cnvSequence("yk"), "ㄔˋ");
  XCTAssertEqual(composer.cnvSequence("ya"), "ㄔㄚ");
  XCTAssertEqual(composer.cnvSequence("yaf"), "ㄔㄚˊ");
  XCTAssertEqual(composer.cnvSequence("yaj"), "ㄔㄚˇ");
  XCTAssertEqual(composer.cnvSequence("yak"), "ㄔㄚˋ");
  XCTAssertEqual(composer.cnvSequence("yr"), "ㄔㄜ");
  XCTAssertEqual(composer.cnvSequence("yrj"), "ㄔㄜˇ");
  XCTAssertEqual(composer.cnvSequence("yrk"), "ㄔㄜˋ");
  XCTAssertEqual(composer.cnvSequence("yi"), "ㄔㄞ");
  XCTAssertEqual(composer.cnvSequence("yif"), "ㄔㄞˊ");
  XCTAssertEqual(composer.cnvSequence("yij"), "ㄔㄞˇ");
  XCTAssertEqual(composer.cnvSequence("yik"), "ㄔㄞˋ");
  XCTAssertEqual(composer.cnvSequence("yz"), "ㄔㄠ");
  XCTAssertEqual(composer.cnvSequence("yzf"), "ㄔㄠˊ");
  XCTAssertEqual(composer.cnvSequence("yzj"), "ㄔㄠˇ");
  XCTAssertEqual(composer.cnvSequence("yzk"), "ㄔㄠˋ");
  XCTAssertEqual(composer.cnvSequence("yp"), "ㄔㄡ");
  XCTAssertEqual(composer.cnvSequence("ypf"), "ㄔㄡˊ");
  XCTAssertEqual(composer.cnvSequence("ypj"), "ㄔㄡˇ");
  XCTAssertEqual(composer.cnvSequence("ypk"), "ㄔㄡˋ");
  XCTAssertEqual(composer.cnvSequence("ym"), "ㄔㄢ");
  XCTAssertEqual(composer.cnvSequence("ymf"), "ㄔㄢˊ");
  XCTAssertEqual(composer.cnvSequence("ymj"), "ㄔㄢˇ");
  XCTAssertEqual(composer.cnvSequence("ymk"), "ㄔㄢˋ");
  XCTAssertEqual(composer.cnvSequence("yn"), "ㄔㄣ");
  XCTAssertEqual(composer.cnvSequence("ynf"), "ㄔㄣˊ");
  XCTAssertEqual(composer.cnvSequence("ynj"), "ㄔㄣˇ");
  XCTAssertEqual(composer.cnvSequence("ynk"), "ㄔㄣˋ");
  XCTAssertEqual(composer.cnvSequence("ynd"), "ㄔㄣ˙");
  XCTAssertEqual(composer.cnvSequence("yt"), "ㄔㄤ");
  XCTAssertEqual(composer.cnvSequence("ytf"), "ㄔㄤˊ");
  XCTAssertEqual(composer.cnvSequence("ytj"), "ㄔㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ytk"), "ㄔㄤˋ");
  XCTAssertEqual(composer.cnvSequence("yl"), "ㄔㄥ");
  XCTAssertEqual(composer.cnvSequence("ylf"), "ㄔㄥˊ");
  XCTAssertEqual(composer.cnvSequence("ylj"), "ㄔㄥˇ");
  XCTAssertEqual(composer.cnvSequence("ylk"), "ㄔㄥˋ");
  XCTAssertEqual(composer.cnvSequence("yx"), "ㄔㄨ");
  XCTAssertEqual(composer.cnvSequence("yxf"), "ㄔㄨˊ");
  XCTAssertEqual(composer.cnvSequence("yxj"), "ㄔㄨˇ");
  XCTAssertEqual(composer.cnvSequence("yxk"), "ㄔㄨˋ");
  XCTAssertEqual(composer.cnvSequence("yxa"), "ㄔㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("yxaj"), "ㄔㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("yxak"), "ㄔㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("yxo"), "ㄔㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("yxok"), "ㄔㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("yxi"), "ㄔㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("yxif"), "ㄔㄨㄞˊ");
  XCTAssertEqual(composer.cnvSequence("yxij"), "ㄔㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("yxik"), "ㄔㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("yxq"), "ㄔㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("yxqf"), "ㄔㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("yxqj"), "ㄔㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("yxqk"), "ㄔㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("yxm"), "ㄔㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("yxmf"), "ㄔㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("yxmj"), "ㄔㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("yxmk"), "ㄔㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("yxn"), "ㄔㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("yxnf"), "ㄔㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("yxnj"), "ㄔㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("yxt"), "ㄔㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("yxtf"), "ㄔㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("yxtj"), "ㄔㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("yxtk"), "ㄔㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("yxl"), "ㄔㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("yxlf"), "ㄔㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("yxlj"), "ㄔㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("yxlk"), "ㄔㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("c"), "ㄕ");
  XCTAssertEqual(composer.cnvSequence("cf"), "ㄕˊ");
  XCTAssertEqual(composer.cnvSequence("cj"), "ㄕˇ");
  XCTAssertEqual(composer.cnvSequence("ck"), "ㄕˋ");
  XCTAssertEqual(composer.cnvSequence("cd"), "ㄕ˙");
  XCTAssertEqual(composer.cnvSequence("ca"), "ㄕㄚ");
  XCTAssertEqual(composer.cnvSequence("caf"), "ㄕㄚˊ");
  XCTAssertEqual(composer.cnvSequence("caj"), "ㄕㄚˇ");
  XCTAssertEqual(composer.cnvSequence("cak"), "ㄕㄚˋ");
  XCTAssertEqual(composer.cnvSequence("cad"), "ㄕㄚ˙");
  XCTAssertEqual(composer.cnvSequence("cr"), "ㄕㄜ");
  XCTAssertEqual(composer.cnvSequence("crf"), "ㄕㄜˊ");
  XCTAssertEqual(composer.cnvSequence("crj"), "ㄕㄜˇ");
  XCTAssertEqual(composer.cnvSequence("crk"), "ㄕㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ci"), "ㄕㄞ");
  XCTAssertEqual(composer.cnvSequence("cij"), "ㄕㄞˇ");
  XCTAssertEqual(composer.cnvSequence("cik"), "ㄕㄞˋ");
  XCTAssertEqual(composer.cnvSequence("cqf"), "ㄕㄟˊ");
  XCTAssertEqual(composer.cnvSequence("cz"), "ㄕㄠ");
  XCTAssertEqual(composer.cnvSequence("czf"), "ㄕㄠˊ");
  XCTAssertEqual(composer.cnvSequence("czj"), "ㄕㄠˇ");
  XCTAssertEqual(composer.cnvSequence("czk"), "ㄕㄠˋ");
  XCTAssertEqual(composer.cnvSequence("cp"), "ㄕㄡ");
  XCTAssertEqual(composer.cnvSequence("cpf"), "ㄕㄡˊ");
  XCTAssertEqual(composer.cnvSequence("cpj"), "ㄕㄡˇ");
  XCTAssertEqual(composer.cnvSequence("cpk"), "ㄕㄡˋ");
  XCTAssertEqual(composer.cnvSequence("cm"), "ㄕㄢ");
  XCTAssertEqual(composer.cnvSequence("cmf"), "ㄕㄢˊ");
  XCTAssertEqual(composer.cnvSequence("cmj"), "ㄕㄢˇ");
  XCTAssertEqual(composer.cnvSequence("cmk"), "ㄕㄢˋ");
  XCTAssertEqual(composer.cnvSequence("cn"), "ㄕㄣ");
  XCTAssertEqual(composer.cnvSequence("cnf"), "ㄕㄣˊ");
  XCTAssertEqual(composer.cnvSequence("cnj"), "ㄕㄣˇ");
  XCTAssertEqual(composer.cnvSequence("cnk"), "ㄕㄣˋ");
  XCTAssertEqual(composer.cnvSequence("ct"), "ㄕㄤ");
  XCTAssertEqual(composer.cnvSequence("ctj"), "ㄕㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ctk"), "ㄕㄤˋ");
  XCTAssertEqual(composer.cnvSequence("ctd"), "ㄕㄤ˙");
  XCTAssertEqual(composer.cnvSequence("cl"), "ㄕㄥ");
  XCTAssertEqual(composer.cnvSequence("clf"), "ㄕㄥˊ");
  XCTAssertEqual(composer.cnvSequence("clj"), "ㄕㄥˇ");
  XCTAssertEqual(composer.cnvSequence("clk"), "ㄕㄥˋ");
  XCTAssertEqual(composer.cnvSequence("cx"), "ㄕㄨ");
  XCTAssertEqual(composer.cnvSequence("cxf"), "ㄕㄨˊ");
  XCTAssertEqual(composer.cnvSequence("cxj"), "ㄕㄨˇ");
  XCTAssertEqual(composer.cnvSequence("cxk"), "ㄕㄨˋ");
  XCTAssertEqual(composer.cnvSequence("cxa"), "ㄕㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("cxaj"), "ㄕㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("cxak"), "ㄕㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("cxo"), "ㄕㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("cxok"), "ㄕㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("cxi"), "ㄕㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("cxij"), "ㄕㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("cxik"), "ㄕㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("cxq"), "ㄕㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("cxqf"), "ㄕㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("cxqj"), "ㄕㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("cxqk"), "ㄕㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("cxm"), "ㄕㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("cxmk"), "ㄕㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("cxnj"), "ㄕㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("cxnk"), "ㄕㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("cxt"), "ㄕㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("cxtf"), "ㄕㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("cxtj"), "ㄕㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("cxtk"), "ㄕㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("jk"), "ㄖˋ");
  XCTAssertEqual(composer.cnvSequence("jrj"), "ㄖㄜˇ");
  XCTAssertEqual(composer.cnvSequence("jrk"), "ㄖㄜˋ");
  XCTAssertEqual(composer.cnvSequence("jzf"), "ㄖㄠˊ");
  XCTAssertEqual(composer.cnvSequence("jzj"), "ㄖㄠˇ");
  XCTAssertEqual(composer.cnvSequence("jzk"), "ㄖㄠˋ");
  XCTAssertEqual(composer.cnvSequence("jpf"), "ㄖㄡˊ");
  XCTAssertEqual(composer.cnvSequence("jpj"), "ㄖㄡˇ");
  XCTAssertEqual(composer.cnvSequence("jpk"), "ㄖㄡˋ");
  XCTAssertEqual(composer.cnvSequence("jmf"), "ㄖㄢˊ");
  XCTAssertEqual(composer.cnvSequence("jmj"), "ㄖㄢˇ");
  XCTAssertEqual(composer.cnvSequence("jmk"), "ㄖㄢˋ");
  XCTAssertEqual(composer.cnvSequence("jnf"), "ㄖㄣˊ");
  XCTAssertEqual(composer.cnvSequence("jnj"), "ㄖㄣˇ");
  XCTAssertEqual(composer.cnvSequence("jnk"), "ㄖㄣˋ");
  XCTAssertEqual(composer.cnvSequence("jt"), "ㄖㄤ");
  XCTAssertEqual(composer.cnvSequence("jtf"), "ㄖㄤˊ");
  XCTAssertEqual(composer.cnvSequence("jtj"), "ㄖㄤˇ");
  XCTAssertEqual(composer.cnvSequence("jtk"), "ㄖㄤˋ");
  XCTAssertEqual(composer.cnvSequence("jl"), "ㄖㄥ");
  XCTAssertEqual(composer.cnvSequence("jlf"), "ㄖㄥˊ");
  XCTAssertEqual(composer.cnvSequence("jlj"), "ㄖㄥˇ");
  XCTAssertEqual(composer.cnvSequence("jlk"), "ㄖㄥˋ");
  XCTAssertEqual(composer.cnvSequence("jxf"), "ㄖㄨˊ");
  XCTAssertEqual(composer.cnvSequence("jxj"), "ㄖㄨˇ");
  XCTAssertEqual(composer.cnvSequence("jxk"), "ㄖㄨˋ");
  XCTAssertEqual(composer.cnvSequence("jxof"), "ㄖㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("jxok"), "ㄖㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("jxqf"), "ㄖㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("jxqj"), "ㄖㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("jxqk"), "ㄖㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("jxmf"), "ㄖㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("jxmj"), "ㄖㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("jxmk"), "ㄖㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("jxnf"), "ㄖㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("jxnj"), "ㄖㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("jxnk"), "ㄖㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("jxlf"), "ㄖㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("jxlj"), "ㄖㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("jxlk"), "ㄖㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("q"), "ㄗ");
  XCTAssertEqual(composer.cnvSequence("qf"), "ㄗˊ");
  XCTAssertEqual(composer.cnvSequence("qj"), "ㄗˇ");
  XCTAssertEqual(composer.cnvSequence("qk"), "ㄗˋ");
  XCTAssertEqual(composer.cnvSequence("qd"), "ㄗ˙");
  XCTAssertEqual(composer.cnvSequence("qa"), "ㄗㄚ");
  XCTAssertEqual(composer.cnvSequence("qaf"), "ㄗㄚˊ");
  XCTAssertEqual(composer.cnvSequence("qaj"), "ㄗㄚˇ");
  XCTAssertEqual(composer.cnvSequence("qrf"), "ㄗㄜˊ");
  XCTAssertEqual(composer.cnvSequence("qrj"), "ㄗㄜˇ");
  XCTAssertEqual(composer.cnvSequence("qrk"), "ㄗㄜˋ");
  XCTAssertEqual(composer.cnvSequence("qi"), "ㄗㄞ");
  XCTAssertEqual(composer.cnvSequence("qij"), "ㄗㄞˇ");
  XCTAssertEqual(composer.cnvSequence("qik"), "ㄗㄞˋ");
  XCTAssertEqual(composer.cnvSequence("qqf"), "ㄗㄟˊ");
  XCTAssertEqual(composer.cnvSequence("qz"), "ㄗㄠ");
  XCTAssertEqual(composer.cnvSequence("qzf"), "ㄗㄠˊ");
  XCTAssertEqual(composer.cnvSequence("qzj"), "ㄗㄠˇ");
  XCTAssertEqual(composer.cnvSequence("qzk"), "ㄗㄠˋ");
  XCTAssertEqual(composer.cnvSequence("qp"), "ㄗㄡ");
  XCTAssertEqual(composer.cnvSequence("qpj"), "ㄗㄡˇ");
  XCTAssertEqual(composer.cnvSequence("qpk"), "ㄗㄡˋ");
  XCTAssertEqual(composer.cnvSequence("qm"), "ㄗㄢ");
  XCTAssertEqual(composer.cnvSequence("qmf"), "ㄗㄢˊ");
  XCTAssertEqual(composer.cnvSequence("qmj"), "ㄗㄢˇ");
  XCTAssertEqual(composer.cnvSequence("qmk"), "ㄗㄢˋ");
  XCTAssertEqual(composer.cnvSequence("qn"), "ㄗㄣ");
  XCTAssertEqual(composer.cnvSequence("qnj"), "ㄗㄣˇ");
  XCTAssertEqual(composer.cnvSequence("qnk"), "ㄗㄣˋ");
  XCTAssertEqual(composer.cnvSequence("qt"), "ㄗㄤ");
  XCTAssertEqual(composer.cnvSequence("qtj"), "ㄗㄤˇ");
  XCTAssertEqual(composer.cnvSequence("qtk"), "ㄗㄤˋ");
  XCTAssertEqual(composer.cnvSequence("ql"), "ㄗㄥ");
  XCTAssertEqual(composer.cnvSequence("qlj"), "ㄗㄥˇ");
  XCTAssertEqual(composer.cnvSequence("qlk"), "ㄗㄥˋ");
  XCTAssertEqual(composer.cnvSequence("qx"), "ㄗㄨ");
  XCTAssertEqual(composer.cnvSequence("qxf"), "ㄗㄨˊ");
  XCTAssertEqual(composer.cnvSequence("qxj"), "ㄗㄨˇ");
  XCTAssertEqual(composer.cnvSequence("qxk"), "ㄗㄨˋ");
  XCTAssertEqual(composer.cnvSequence("qxo"), "ㄗㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("qxof"), "ㄗㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("qxoj"), "ㄗㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("qxok"), "ㄗㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("qxod"), "ㄗㄨㄛ˙");
  XCTAssertEqual(composer.cnvSequence("qxq"), "ㄗㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("qxqj"), "ㄗㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("qxqk"), "ㄗㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("qxm"), "ㄗㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("qxmj"), "ㄗㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("qxmk"), "ㄗㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("qxn"), "ㄗㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("qxnj"), "ㄗㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("qxnk"), "ㄗㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("qxl"), "ㄗㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("qxlj"), "ㄗㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("qxlk"), "ㄗㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("w"), "ㄘ");
  XCTAssertEqual(composer.cnvSequence("wf"), "ㄘˊ");
  XCTAssertEqual(composer.cnvSequence("wj"), "ㄘˇ");
  XCTAssertEqual(composer.cnvSequence("wk"), "ㄘˋ");
  XCTAssertEqual(composer.cnvSequence("wa"), "ㄘㄚ");
  XCTAssertEqual(composer.cnvSequence("waj"), "ㄘㄚˇ");
  XCTAssertEqual(composer.cnvSequence("wak"), "ㄘㄚˋ");
  XCTAssertEqual(composer.cnvSequence("wrk"), "ㄘㄜˋ");
  XCTAssertEqual(composer.cnvSequence("wi"), "ㄘㄞ");
  XCTAssertEqual(composer.cnvSequence("wif"), "ㄘㄞˊ");
  XCTAssertEqual(composer.cnvSequence("wij"), "ㄘㄞˇ");
  XCTAssertEqual(composer.cnvSequence("wik"), "ㄘㄞˋ");
  XCTAssertEqual(composer.cnvSequence("wz"), "ㄘㄠ");
  XCTAssertEqual(composer.cnvSequence("wzf"), "ㄘㄠˊ");
  XCTAssertEqual(composer.cnvSequence("wzj"), "ㄘㄠˇ");
  XCTAssertEqual(composer.cnvSequence("wzk"), "ㄘㄠˋ");
  XCTAssertEqual(composer.cnvSequence("wp"), "ㄘㄡ");
  XCTAssertEqual(composer.cnvSequence("wpf"), "ㄘㄡˊ");
  XCTAssertEqual(composer.cnvSequence("wpj"), "ㄘㄡˇ");
  XCTAssertEqual(composer.cnvSequence("wpk"), "ㄘㄡˋ");
  XCTAssertEqual(composer.cnvSequence("wm"), "ㄘㄢ");
  XCTAssertEqual(composer.cnvSequence("wmf"), "ㄘㄢˊ");
  XCTAssertEqual(composer.cnvSequence("wmj"), "ㄘㄢˇ");
  XCTAssertEqual(composer.cnvSequence("wmk"), "ㄘㄢˋ");
  XCTAssertEqual(composer.cnvSequence("wn"), "ㄘㄣ");
  XCTAssertEqual(composer.cnvSequence("wnf"), "ㄘㄣˊ");
  XCTAssertEqual(composer.cnvSequence("wt"), "ㄘㄤ");
  XCTAssertEqual(composer.cnvSequence("wtf"), "ㄘㄤˊ");
  XCTAssertEqual(composer.cnvSequence("wtj"), "ㄘㄤˇ");
  XCTAssertEqual(composer.cnvSequence("wtk"), "ㄘㄤˋ");
  XCTAssertEqual(composer.cnvSequence("wl"), "ㄘㄥ");
  XCTAssertEqual(composer.cnvSequence("wlf"), "ㄘㄥˊ");
  XCTAssertEqual(composer.cnvSequence("wlj"), "ㄘㄥˇ");
  XCTAssertEqual(composer.cnvSequence("wlk"), "ㄘㄥˋ");
  XCTAssertEqual(composer.cnvSequence("wx"), "ㄘㄨ");
  XCTAssertEqual(composer.cnvSequence("wxf"), "ㄘㄨˊ");
  XCTAssertEqual(composer.cnvSequence("wxj"), "ㄘㄨˇ");
  XCTAssertEqual(composer.cnvSequence("wxk"), "ㄘㄨˋ");
  XCTAssertEqual(composer.cnvSequence("wxo"), "ㄘㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("wxof"), "ㄘㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("wxoj"), "ㄘㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("wxok"), "ㄘㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("wxq"), "ㄘㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("wxqj"), "ㄘㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("wxqk"), "ㄘㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("wxm"), "ㄘㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("wxmf"), "ㄘㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("wxmj"), "ㄘㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("wxmk"), "ㄘㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("wxn"), "ㄘㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("wxnf"), "ㄘㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("wxnj"), "ㄘㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("wxnk"), "ㄘㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("wxl"), "ㄘㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("wxlf"), "ㄘㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("wxlj"), "ㄘㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("wxlk"), "ㄘㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("s"), "ㄙ");
  XCTAssertEqual(composer.cnvSequence("sj"), "ㄙˇ");
  XCTAssertEqual(composer.cnvSequence("sk"), "ㄙˋ");
  XCTAssertEqual(composer.cnvSequence("sa"), "ㄙㄚ");
  XCTAssertEqual(composer.cnvSequence("saj"), "ㄙㄚˇ");
  XCTAssertEqual(composer.cnvSequence("sak"), "ㄙㄚˋ");
  XCTAssertEqual(composer.cnvSequence("sad"), "ㄙㄚ˙");
  XCTAssertEqual(composer.cnvSequence("sr"), "ㄙㄜ");
  XCTAssertEqual(composer.cnvSequence("srk"), "ㄙㄜˋ");
  XCTAssertEqual(composer.cnvSequence("si"), "ㄙㄞ");
  XCTAssertEqual(composer.cnvSequence("sif"), "ㄙㄞˊ");
  XCTAssertEqual(composer.cnvSequence("sij"), "ㄙㄞˇ");
  XCTAssertEqual(composer.cnvSequence("sik"), "ㄙㄞˋ");
  XCTAssertEqual(composer.cnvSequence("sq"), "ㄙㄟ");
  XCTAssertEqual(composer.cnvSequence("sz"), "ㄙㄠ");
  XCTAssertEqual(composer.cnvSequence("szj"), "ㄙㄠˇ");
  XCTAssertEqual(composer.cnvSequence("szk"), "ㄙㄠˋ");
  XCTAssertEqual(composer.cnvSequence("sp"), "ㄙㄡ");
  XCTAssertEqual(composer.cnvSequence("spj"), "ㄙㄡˇ");
  XCTAssertEqual(composer.cnvSequence("spk"), "ㄙㄡˋ");
  XCTAssertEqual(composer.cnvSequence("sm"), "ㄙㄢ");
  XCTAssertEqual(composer.cnvSequence("smj"), "ㄙㄢˇ");
  XCTAssertEqual(composer.cnvSequence("smk"), "ㄙㄢˋ");
  XCTAssertEqual(composer.cnvSequence("sn"), "ㄙㄣ");
  XCTAssertEqual(composer.cnvSequence("snj"), "ㄙㄣˇ");
  XCTAssertEqual(composer.cnvSequence("st"), "ㄙㄤ");
  XCTAssertEqual(composer.cnvSequence("stj"), "ㄙㄤˇ");
  XCTAssertEqual(composer.cnvSequence("stk"), "ㄙㄤˋ");
  XCTAssertEqual(composer.cnvSequence("sl"), "ㄙㄥ");
  XCTAssertEqual(composer.cnvSequence("slk"), "ㄙㄥˋ");
  XCTAssertEqual(composer.cnvSequence("sx"), "ㄙㄨ");
  XCTAssertEqual(composer.cnvSequence("sxf"), "ㄙㄨˊ");
  XCTAssertEqual(composer.cnvSequence("sxj"), "ㄙㄨˇ");
  XCTAssertEqual(composer.cnvSequence("sxk"), "ㄙㄨˋ");
  XCTAssertEqual(composer.cnvSequence("sxo"), "ㄙㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("sxof"), "ㄙㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("sxoj"), "ㄙㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("sxok"), "ㄙㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("sxq"), "ㄙㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("sxqf"), "ㄙㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("sxqj"), "ㄙㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("sxqk"), "ㄙㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("sxm"), "ㄙㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("sxmj"), "ㄙㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("sxmk"), "ㄙㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("sxn"), "ㄙㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("sxnj"), "ㄙㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("sxnk"), "ㄙㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("sxl"), "ㄙㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("sxlf"), "ㄙㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("sxlj"), "ㄙㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("sxlk"), "ㄙㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("a"), "ㄚ");
  XCTAssertEqual(composer.cnvSequence("af"), "ㄚˊ");
  XCTAssertEqual(composer.cnvSequence("ak"), "ㄚˋ");
  XCTAssertEqual(composer.cnvSequence("ad"), "ㄚ˙");
  XCTAssertEqual(composer.cnvSequence("o"), "ㄛ");
  XCTAssertEqual(composer.cnvSequence("of"), "ㄛˊ");
  XCTAssertEqual(composer.cnvSequence("oj"), "ㄛˇ");
  XCTAssertEqual(composer.cnvSequence("ok"), "ㄛˋ");
  XCTAssertEqual(composer.cnvSequence("r"), "ㄜ");
  XCTAssertEqual(composer.cnvSequence("rf"), "ㄜˊ");
  XCTAssertEqual(composer.cnvSequence("rj"), "ㄜˇ");
  XCTAssertEqual(composer.cnvSequence("rk"), "ㄜˋ");
  // XCTAssertEqual(composer.cnvSequence("wf"), "ㄝˊ");
  // XCTAssertEqual(composer.cnvSequence("wj"), "ㄝˇ");
  // XCTAssertEqual(composer.cnvSequence("wk"), "ㄝˋ");
  // XCTAssertEqual(composer.cnvSequence("wd"), "ㄝ˙");
  XCTAssertEqual(composer.cnvSequence("i"), "ㄞ");
  XCTAssertEqual(composer.cnvSequence("if"), "ㄞˊ");
  XCTAssertEqual(composer.cnvSequence("ij"), "ㄞˇ");
  XCTAssertEqual(composer.cnvSequence("ik"), "ㄞˋ");
  // XCTAssertEqual(composer.cnvSequence("qk"), "ㄟˋ");
  XCTAssertEqual(composer.cnvSequence("z"), "ㄠ");
  XCTAssertEqual(composer.cnvSequence("zf"), "ㄠˊ");
  XCTAssertEqual(composer.cnvSequence("zj"), "ㄠˇ");
  XCTAssertEqual(composer.cnvSequence("zk"), "ㄠˋ");
  XCTAssertEqual(composer.cnvSequence("p"), "ㄡ");
  XCTAssertEqual(composer.cnvSequence("pf"), "ㄡˊ");
  XCTAssertEqual(composer.cnvSequence("pj"), "ㄡˇ");
  XCTAssertEqual(composer.cnvSequence("pk"), "ㄡˋ");
  XCTAssertEqual(composer.cnvSequence("pd"), "ㄡ˙");
  XCTAssertEqual(composer.cnvSequence("m"), "ㄢ");
  XCTAssertEqual(composer.cnvSequence("mf"), "ㄢˊ");
  XCTAssertEqual(composer.cnvSequence("mj"), "ㄢˇ");
  XCTAssertEqual(composer.cnvSequence("mk"), "ㄢˋ");
  XCTAssertEqual(composer.cnvSequence("n"), "ㄣ");
  XCTAssertEqual(composer.cnvSequence("nf"), "ㄣˊ");
  XCTAssertEqual(composer.cnvSequence("nj"), "ㄣˇ");
  XCTAssertEqual(composer.cnvSequence("nk"), "ㄣˋ");
  XCTAssertEqual(composer.cnvSequence("nd"), "ㄣ˙");
  XCTAssertEqual(composer.cnvSequence("t"), "ㄤ");
  XCTAssertEqual(composer.cnvSequence("tf"), "ㄤˊ");
  XCTAssertEqual(composer.cnvSequence("tj"), "ㄤˇ");
  XCTAssertEqual(composer.cnvSequence("tk"), "ㄤˋ");
  XCTAssertEqual(composer.cnvSequence("l"), "ㄥ");
  XCTAssertEqual(composer.cnvSequence("lk"), "ㄥˋ");
  XCTAssertEqual(composer.cnvSequence("h"), "ㄦ");
  XCTAssertEqual(composer.cnvSequence("hf"), "ㄦˊ");
  XCTAssertEqual(composer.cnvSequence("hj"), "ㄦˇ");
  XCTAssertEqual(composer.cnvSequence("hk"), "ㄦˋ");
  XCTAssertEqual(composer.cnvSequence("hd"), "ㄦ˙");
  XCTAssertEqual(composer.cnvSequence("e"), "ㄧ");
  XCTAssertEqual(composer.cnvSequence("ef"), "ㄧˊ");
  XCTAssertEqual(composer.cnvSequence("ej"), "ㄧˇ");
  XCTAssertEqual(composer.cnvSequence("ek"), "ㄧˋ");
  XCTAssertEqual(composer.cnvSequence("ea"), "ㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("eaf"), "ㄧㄚˊ");
  XCTAssertEqual(composer.cnvSequence("eaj"), "ㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("eak"), "ㄧㄚˋ");
  XCTAssertEqual(composer.cnvSequence("ead"), "ㄧㄚ˙");
  XCTAssertEqual(composer.cnvSequence("eo"), "ㄧㄛ");
  XCTAssertEqual(composer.cnvSequence("eod"), "ㄧㄛ˙");
  XCTAssertEqual(composer.cnvSequence("ew"), "ㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("ewf"), "ㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("ewj"), "ㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("ewk"), "ㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("ewd"), "ㄧㄝ˙");
  XCTAssertEqual(composer.cnvSequence("eif"), "ㄧㄞˊ");
  XCTAssertEqual(composer.cnvSequence("ez"), "ㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("ezf"), "ㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("ezj"), "ㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("ezk"), "ㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("ep"), "ㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("epf"), "ㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("epj"), "ㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("epk"), "ㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("em"), "ㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("emf"), "ㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("emj"), "ㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("emk"), "ㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("en"), "ㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("enf"), "ㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("enj"), "ㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("enk"), "ㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("et"), "ㄧㄤ");
  XCTAssertEqual(composer.cnvSequence("etf"), "ㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("etj"), "ㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("etk"), "ㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("el"), "ㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("elf"), "ㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("elj"), "ㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("elk"), "ㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("x"), "ㄨ");
  XCTAssertEqual(composer.cnvSequence("xf"), "ㄨˊ");
  XCTAssertEqual(composer.cnvSequence("xj"), "ㄨˇ");
  XCTAssertEqual(composer.cnvSequence("xk"), "ㄨˋ");
  XCTAssertEqual(composer.cnvSequence("xa"), "ㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("xaf"), "ㄨㄚˊ");
  XCTAssertEqual(composer.cnvSequence("xaj"), "ㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("xak"), "ㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("xad"), "ㄨㄚ˙");
  XCTAssertEqual(composer.cnvSequence("xo"), "ㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("xoj"), "ㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("xok"), "ㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("xi"), "ㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("xij"), "ㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("xik"), "ㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("xq"), "ㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("xqf"), "ㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("xqj"), "ㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("xqk"), "ㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("xm"), "ㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("xmf"), "ㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("xmj"), "ㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("xmk"), "ㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("xn"), "ㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("xnf"), "ㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("xnj"), "ㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("xnk"), "ㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("xt"), "ㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("xtf"), "ㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("xtj"), "ㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("xtk"), "ㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("xl"), "ㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("xlj"), "ㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("xlk"), "ㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("u"), "ㄩ");
  XCTAssertEqual(composer.cnvSequence("uf"), "ㄩˊ");
  XCTAssertEqual(composer.cnvSequence("uj"), "ㄩˇ");
  XCTAssertEqual(composer.cnvSequence("uk"), "ㄩˋ");
  XCTAssertEqual(composer.cnvSequence("uw"), "ㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("uwj"), "ㄩㄝˇ");
  XCTAssertEqual(composer.cnvSequence("uwk"), "ㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("um"), "ㄩㄢ");
  XCTAssertEqual(composer.cnvSequence("umf"), "ㄩㄢˊ");
  XCTAssertEqual(composer.cnvSequence("umj"), "ㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("umk"), "ㄩㄢˋ");
  XCTAssertEqual(composer.cnvSequence("un"), "ㄩㄣ");
  XCTAssertEqual(composer.cnvSequence("unf"), "ㄩㄣˊ");
  XCTAssertEqual(composer.cnvSequence("unj"), "ㄩㄣˇ");
  XCTAssertEqual(composer.cnvSequence("unk"), "ㄩㄣˋ");
  XCTAssertEqual(composer.cnvSequence("ul"), "ㄩㄥ");
  XCTAssertEqual(composer.cnvSequence("ulf"), "ㄩㄥˊ");
  XCTAssertEqual(composer.cnvSequence("ulj"), "ㄩㄥˇ");
  XCTAssertEqual(composer.cnvSequence("ulk"), "ㄩㄥˋ");
}

- (void)testHsu {
  BopomofoReadingBuffer composer(BopomofoKeyboardLayout::HsuLayout());
  XCTAssertEqual(composer.cnvSequence("kek"), "ㄎㄧㄤ");
  // AreEqual(Composer.cnvSequence("vezf"), "ㄍㄧㄠˊ");
  // AreEqual(Composer.cnvSequence("gen"), "ㄍㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("bekd"), "ㄅㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("bekj"), "ㄅㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("dxk"), "ㄉㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("by"), "ㄅㄚ");
  XCTAssertEqual(composer.cnvSequence("byd"), "ㄅㄚˊ");
  XCTAssertEqual(composer.cnvSequence("byf"), "ㄅㄚˇ");
  XCTAssertEqual(composer.cnvSequence("byj"), "ㄅㄚˋ");
  XCTAssertEqual(composer.cnvSequence("bys"), "ㄅㄚ˙");
  XCTAssertEqual(composer.cnvSequence("bh"), "ㄅㄛ");
  XCTAssertEqual(composer.cnvSequence("bhd"), "ㄅㄛˊ");
  XCTAssertEqual(composer.cnvSequence("bhf"), "ㄅㄛˇ");
  XCTAssertEqual(composer.cnvSequence("bhj"), "ㄅㄛˋ");
  XCTAssertEqual(composer.cnvSequence("bhs"), "ㄅㄛ˙");
  XCTAssertEqual(composer.cnvSequence("bi"), "ㄅㄞ");
  XCTAssertEqual(composer.cnvSequence("bid"), "ㄅㄞˊ");
  XCTAssertEqual(composer.cnvSequence("bif"), "ㄅㄞˇ");
  XCTAssertEqual(composer.cnvSequence("bij"), "ㄅㄞˋ");
  XCTAssertEqual(composer.cnvSequence("bis"), "ㄅㄞ˙");
  XCTAssertEqual(composer.cnvSequence("ba"), "ㄅㄟ");
  XCTAssertEqual(composer.cnvSequence("baf"), "ㄅㄟˇ");
  XCTAssertEqual(composer.cnvSequence("baj"), "ㄅㄟˋ");
  XCTAssertEqual(composer.cnvSequence("bas"), "ㄅㄟ˙");
  XCTAssertEqual(composer.cnvSequence("bw"), "ㄅㄠ");
  XCTAssertEqual(composer.cnvSequence("bwd"), "ㄅㄠˊ");
  XCTAssertEqual(composer.cnvSequence("bwf"), "ㄅㄠˇ");
  XCTAssertEqual(composer.cnvSequence("bwj"), "ㄅㄠˋ");
  XCTAssertEqual(composer.cnvSequence("bm"), "ㄅㄢ");
  XCTAssertEqual(composer.cnvSequence("bmf"), "ㄅㄢˇ");
  XCTAssertEqual(composer.cnvSequence("bmj"), "ㄅㄢˋ");
  XCTAssertEqual(composer.cnvSequence("bn"), "ㄅㄣ");
  XCTAssertEqual(composer.cnvSequence("bnf"), "ㄅㄣˇ");
  XCTAssertEqual(composer.cnvSequence("bnj"), "ㄅㄣˋ");
  XCTAssertEqual(composer.cnvSequence("bk"), "ㄅㄤ");
  XCTAssertEqual(composer.cnvSequence("bkf"), "ㄅㄤˇ");
  XCTAssertEqual(composer.cnvSequence("bkj"), "ㄅㄤˋ");
  XCTAssertEqual(composer.cnvSequence("bl"), "ㄅㄥ");
  XCTAssertEqual(composer.cnvSequence("bld"), "ㄅㄥˊ");
  XCTAssertEqual(composer.cnvSequence("blf"), "ㄅㄥˇ");
  XCTAssertEqual(composer.cnvSequence("blj"), "ㄅㄥˋ");
  XCTAssertEqual(composer.cnvSequence("be"), "ㄅㄧ");
  XCTAssertEqual(composer.cnvSequence("bed"), "ㄅㄧˊ");
  XCTAssertEqual(composer.cnvSequence("bef"), "ㄅㄧˇ");
  XCTAssertEqual(composer.cnvSequence("bej"), "ㄅㄧˋ");
  XCTAssertEqual(composer.cnvSequence("bee"), "ㄅㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("beed"), "ㄅㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("beef"), "ㄅㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("beej"), "ㄅㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("bew"), "ㄅㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("bewf"), "ㄅㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("bewj"), "ㄅㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("bem"), "ㄅㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("bemd"), "ㄅㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("bemf"), "ㄅㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("bemj"), "ㄅㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("ben"), "ㄅㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("benf"), "ㄅㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("benj"), "ㄅㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("bel"), "ㄅㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("belf"), "ㄅㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("belj"), "ㄅㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("bx"), "ㄅㄨ");
  XCTAssertEqual(composer.cnvSequence("bxd"), "ㄅㄨˊ");
  XCTAssertEqual(composer.cnvSequence("bxf"), "ㄅㄨˇ");
  XCTAssertEqual(composer.cnvSequence("bxj"), "ㄅㄨˋ");
  XCTAssertEqual(composer.cnvSequence("py"), "ㄆㄚ");
  XCTAssertEqual(composer.cnvSequence("pyd"), "ㄆㄚˊ");
  XCTAssertEqual(composer.cnvSequence("pyf"), "ㄆㄚˇ");
  XCTAssertEqual(composer.cnvSequence("pyj"), "ㄆㄚˋ");
  XCTAssertEqual(composer.cnvSequence("pys"), "ㄆㄚ˙");
  XCTAssertEqual(composer.cnvSequence("ph"), "ㄆㄛ");
  XCTAssertEqual(composer.cnvSequence("phd"), "ㄆㄛˊ");
  XCTAssertEqual(composer.cnvSequence("phf"), "ㄆㄛˇ");
  XCTAssertEqual(composer.cnvSequence("phj"), "ㄆㄛˋ");
  XCTAssertEqual(composer.cnvSequence("pi"), "ㄆㄞ");
  XCTAssertEqual(composer.cnvSequence("pid"), "ㄆㄞˊ");
  XCTAssertEqual(composer.cnvSequence("pif"), "ㄆㄞˇ");
  XCTAssertEqual(composer.cnvSequence("pij"), "ㄆㄞˋ");
  XCTAssertEqual(composer.cnvSequence("pa"), "ㄆㄟ");
  XCTAssertEqual(composer.cnvSequence("pad"), "ㄆㄟˊ");
  XCTAssertEqual(composer.cnvSequence("paf"), "ㄆㄟˇ");
  XCTAssertEqual(composer.cnvSequence("paj"), "ㄆㄟˋ");
  XCTAssertEqual(composer.cnvSequence("pw"), "ㄆㄠ");
  XCTAssertEqual(composer.cnvSequence("pwd"), "ㄆㄠˊ");
  XCTAssertEqual(composer.cnvSequence("pwf"), "ㄆㄠˇ");
  XCTAssertEqual(composer.cnvSequence("pwj"), "ㄆㄠˋ");
  XCTAssertEqual(composer.cnvSequence("po"), "ㄆㄡ");
  XCTAssertEqual(composer.cnvSequence("pod"), "ㄆㄡˊ");
  XCTAssertEqual(composer.cnvSequence("pof"), "ㄆㄡˇ");
  XCTAssertEqual(composer.cnvSequence("poj"), "ㄆㄡˋ");
  XCTAssertEqual(composer.cnvSequence("pm"), "ㄆㄢ");
  XCTAssertEqual(composer.cnvSequence("pmd"), "ㄆㄢˊ");
  XCTAssertEqual(composer.cnvSequence("pmf"), "ㄆㄢˇ");
  XCTAssertEqual(composer.cnvSequence("pmj"), "ㄆㄢˋ");
  XCTAssertEqual(composer.cnvSequence("pn"), "ㄆㄣ");
  XCTAssertEqual(composer.cnvSequence("pnd"), "ㄆㄣˊ");
  XCTAssertEqual(composer.cnvSequence("pnf"), "ㄆㄣˇ");
  XCTAssertEqual(composer.cnvSequence("pnj"), "ㄆㄣˋ");
  XCTAssertEqual(composer.cnvSequence("pk"), "ㄆㄤ");
  XCTAssertEqual(composer.cnvSequence("pkd"), "ㄆㄤˊ");
  XCTAssertEqual(composer.cnvSequence("pkf"), "ㄆㄤˇ");
  XCTAssertEqual(composer.cnvSequence("pkj"), "ㄆㄤˋ");
  XCTAssertEqual(composer.cnvSequence("pl"), "ㄆㄥ");
  XCTAssertEqual(composer.cnvSequence("pld"), "ㄆㄥˊ");
  XCTAssertEqual(composer.cnvSequence("plf"), "ㄆㄥˇ");
  XCTAssertEqual(composer.cnvSequence("plj"), "ㄆㄥˋ");
  XCTAssertEqual(composer.cnvSequence("pe"), "ㄆㄧ");
  XCTAssertEqual(composer.cnvSequence("ped"), "ㄆㄧˊ");
  XCTAssertEqual(composer.cnvSequence("pef"), "ㄆㄧˇ");
  XCTAssertEqual(composer.cnvSequence("pej"), "ㄆㄧˋ");
  XCTAssertEqual(composer.cnvSequence("pey"), "ㄆㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("pee"), "ㄆㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("peef"), "ㄆㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("peej"), "ㄆㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("pew"), "ㄆㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("pewd"), "ㄆㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("pewf"), "ㄆㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("pewj"), "ㄆㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("pem"), "ㄆㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("pemd"), "ㄆㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("pemf"), "ㄆㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("pemj"), "ㄆㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("pen"), "ㄆㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("pend"), "ㄆㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("penf"), "ㄆㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("penj"), "ㄆㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("pel"), "ㄆㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("peld"), "ㄆㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("pelf"), "ㄆㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("pelj"), "ㄆㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("px"), "ㄆㄨ");
  XCTAssertEqual(composer.cnvSequence("pxd"), "ㄆㄨˊ");
  XCTAssertEqual(composer.cnvSequence("pxf"), "ㄆㄨˇ");
  XCTAssertEqual(composer.cnvSequence("pxj"), "ㄆㄨˋ");
  XCTAssertEqual(composer.cnvSequence("my"), "ㄇㄚ");
  XCTAssertEqual(composer.cnvSequence("myd"), "ㄇㄚˊ");
  XCTAssertEqual(composer.cnvSequence("myf"), "ㄇㄚˇ");
  XCTAssertEqual(composer.cnvSequence("myj"), "ㄇㄚˋ");
  XCTAssertEqual(composer.cnvSequence("mys"), "ㄇㄚ˙");
  XCTAssertEqual(composer.cnvSequence("mh"), "ㄇㄛ");
  XCTAssertEqual(composer.cnvSequence("mhd"), "ㄇㄛˊ");
  XCTAssertEqual(composer.cnvSequence("mhf"), "ㄇㄛˇ");
  XCTAssertEqual(composer.cnvSequence("mhj"), "ㄇㄛˋ");
  XCTAssertEqual(composer.cnvSequence("mhs"), "ㄇㄛ˙");
  XCTAssertEqual(composer.cnvSequence("mg"), "ㄇㄜ");
  XCTAssertEqual(composer.cnvSequence("mgj"), "ㄇㄜˋ");
  XCTAssertEqual(composer.cnvSequence("mgs"), "ㄇㄜ˙");
  XCTAssertEqual(composer.cnvSequence("mi"), "ㄇㄞ");
  XCTAssertEqual(composer.cnvSequence("mid"), "ㄇㄞˊ");
  XCTAssertEqual(composer.cnvSequence("mif"), "ㄇㄞˇ");
  XCTAssertEqual(composer.cnvSequence("mij"), "ㄇㄞˋ");
  XCTAssertEqual(composer.cnvSequence("mad"), "ㄇㄟˊ");
  XCTAssertEqual(composer.cnvSequence("maf"), "ㄇㄟˇ");
  XCTAssertEqual(composer.cnvSequence("maj"), "ㄇㄟˋ");
  XCTAssertEqual(composer.cnvSequence("mw"), "ㄇㄠ");
  XCTAssertEqual(composer.cnvSequence("mwd"), "ㄇㄠˊ");
  XCTAssertEqual(composer.cnvSequence("mwf"), "ㄇㄠˇ");
  XCTAssertEqual(composer.cnvSequence("mwj"), "ㄇㄠˋ");
  XCTAssertEqual(composer.cnvSequence("mod"), "ㄇㄡˊ");
  XCTAssertEqual(composer.cnvSequence("mof"), "ㄇㄡˇ");
  XCTAssertEqual(composer.cnvSequence("moj"), "ㄇㄡˋ");
  XCTAssertEqual(composer.cnvSequence("mm"), "ㄇㄢ");
  XCTAssertEqual(composer.cnvSequence("mmd"), "ㄇㄢˊ");
  XCTAssertEqual(composer.cnvSequence("mmf"), "ㄇㄢˇ");
  XCTAssertEqual(composer.cnvSequence("mmj"), "ㄇㄢˋ");
  XCTAssertEqual(composer.cnvSequence("mn"), "ㄇㄣ");
  XCTAssertEqual(composer.cnvSequence("mnd"), "ㄇㄣˊ");
  XCTAssertEqual(composer.cnvSequence("mnf"), "ㄇㄣˇ");
  XCTAssertEqual(composer.cnvSequence("mnj"), "ㄇㄣˋ");
  XCTAssertEqual(composer.cnvSequence("mns"), "ㄇㄣ˙");
  XCTAssertEqual(composer.cnvSequence("mk"), "ㄇㄤ");
  XCTAssertEqual(composer.cnvSequence("mkd"), "ㄇㄤˊ");
  XCTAssertEqual(composer.cnvSequence("mkf"), "ㄇㄤˇ");
  XCTAssertEqual(composer.cnvSequence("mkj"), "ㄇㄤˋ");
  XCTAssertEqual(composer.cnvSequence("ml"), "ㄇㄥ");
  XCTAssertEqual(composer.cnvSequence("mld"), "ㄇㄥˊ");
  XCTAssertEqual(composer.cnvSequence("mlf"), "ㄇㄥˇ");
  XCTAssertEqual(composer.cnvSequence("mlj"), "ㄇㄥˋ");
  XCTAssertEqual(composer.cnvSequence("me"), "ㄇㄧ");
  XCTAssertEqual(composer.cnvSequence("med"), "ㄇㄧˊ");
  XCTAssertEqual(composer.cnvSequence("mef"), "ㄇㄧˇ");
  XCTAssertEqual(composer.cnvSequence("mej"), "ㄇㄧˋ");
  XCTAssertEqual(composer.cnvSequence("mee"), "ㄇㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("meed"), "ㄇㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("meej"), "ㄇㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("mew"), "ㄇㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("mewd"), "ㄇㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("mewf"), "ㄇㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("mewj"), "ㄇㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("meod"), "ㄇㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("meof"), "ㄇㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("meoj"), "ㄇㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("mem"), "ㄇㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("memd"), "ㄇㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("memf"), "ㄇㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("memj"), "ㄇㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("men"), "ㄇㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("mend"), "ㄇㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("menf"), "ㄇㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("meld"), "ㄇㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("melf"), "ㄇㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("melj"), "ㄇㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("mxd"), "ㄇㄨˊ");
  XCTAssertEqual(composer.cnvSequence("mxf"), "ㄇㄨˇ");
  XCTAssertEqual(composer.cnvSequence("mxj"), "ㄇㄨˋ");
  XCTAssertEqual(composer.cnvSequence("fy"), "ㄈㄚ");
  XCTAssertEqual(composer.cnvSequence("fyd"), "ㄈㄚˊ");
  XCTAssertEqual(composer.cnvSequence("fyf"), "ㄈㄚˇ");
  XCTAssertEqual(composer.cnvSequence("fyj"), "ㄈㄚˋ");
  XCTAssertEqual(composer.cnvSequence("fhd"), "ㄈㄛˊ");
  XCTAssertEqual(composer.cnvSequence("fa"), "ㄈㄟ");
  XCTAssertEqual(composer.cnvSequence("fad"), "ㄈㄟˊ");
  XCTAssertEqual(composer.cnvSequence("faf"), "ㄈㄟˇ");
  XCTAssertEqual(composer.cnvSequence("faj"), "ㄈㄟˋ");
  XCTAssertEqual(composer.cnvSequence("fo"), "ㄈㄡ");
  XCTAssertEqual(composer.cnvSequence("fod"), "ㄈㄡˊ");
  XCTAssertEqual(composer.cnvSequence("fof"), "ㄈㄡˇ");
  XCTAssertEqual(composer.cnvSequence("foj"), "ㄈㄡˋ");
  XCTAssertEqual(composer.cnvSequence("fm"), "ㄈㄢ");
  XCTAssertEqual(composer.cnvSequence("fmd"), "ㄈㄢˊ");
  XCTAssertEqual(composer.cnvSequence("fmf"), "ㄈㄢˇ");
  XCTAssertEqual(composer.cnvSequence("fmj"), "ㄈㄢˋ");
  XCTAssertEqual(composer.cnvSequence("fn"), "ㄈㄣ");
  XCTAssertEqual(composer.cnvSequence("fnd"), "ㄈㄣˊ");
  XCTAssertEqual(composer.cnvSequence("fnf"), "ㄈㄣˇ");
  XCTAssertEqual(composer.cnvSequence("fnj"), "ㄈㄣˋ");
  XCTAssertEqual(composer.cnvSequence("fns"), "ㄈㄣ˙");
  XCTAssertEqual(composer.cnvSequence("fk"), "ㄈㄤ");
  XCTAssertEqual(composer.cnvSequence("fkd"), "ㄈㄤˊ");
  XCTAssertEqual(composer.cnvSequence("fkf"), "ㄈㄤˇ");
  XCTAssertEqual(composer.cnvSequence("fkj"), "ㄈㄤˋ");
  XCTAssertEqual(composer.cnvSequence("fl"), "ㄈㄥ");
  XCTAssertEqual(composer.cnvSequence("fld"), "ㄈㄥˊ");
  XCTAssertEqual(composer.cnvSequence("flf"), "ㄈㄥˇ");
  XCTAssertEqual(composer.cnvSequence("flj"), "ㄈㄥˋ");
  XCTAssertEqual(composer.cnvSequence("fewj"), "ㄈㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("fx"), "ㄈㄨ");
  XCTAssertEqual(composer.cnvSequence("fxd"), "ㄈㄨˊ");
  XCTAssertEqual(composer.cnvSequence("fxf"), "ㄈㄨˇ");
  XCTAssertEqual(composer.cnvSequence("fxj"), "ㄈㄨˋ");
  XCTAssertEqual(composer.cnvSequence("dy"), "ㄉㄚ");
  XCTAssertEqual(composer.cnvSequence("dyd"), "ㄉㄚˊ");
  XCTAssertEqual(composer.cnvSequence("dyf"), "ㄉㄚˇ");
  XCTAssertEqual(composer.cnvSequence("dyj"), "ㄉㄚˋ");
  XCTAssertEqual(composer.cnvSequence("dys"), "ㄉㄚ˙");
  XCTAssertEqual(composer.cnvSequence("dg"), "ㄉㄜ");
  XCTAssertEqual(composer.cnvSequence("dgd"), "ㄉㄜˊ");
  XCTAssertEqual(composer.cnvSequence("dgs"), "ㄉㄜ˙");
  XCTAssertEqual(composer.cnvSequence("di"), "ㄉㄞ");
  XCTAssertEqual(composer.cnvSequence("dif"), "ㄉㄞˇ");
  XCTAssertEqual(composer.cnvSequence("dij"), "ㄉㄞˋ");
  XCTAssertEqual(composer.cnvSequence("daf"), "ㄉㄟˇ");
  XCTAssertEqual(composer.cnvSequence("dw"), "ㄉㄠ");
  XCTAssertEqual(composer.cnvSequence("dwd"), "ㄉㄠˊ");
  XCTAssertEqual(composer.cnvSequence("dwf"), "ㄉㄠˇ");
  XCTAssertEqual(composer.cnvSequence("dwj"), "ㄉㄠˋ");
  XCTAssertEqual(composer.cnvSequence("do"), "ㄉㄡ");
  XCTAssertEqual(composer.cnvSequence("dod"), "ㄉㄡˊ");
  XCTAssertEqual(composer.cnvSequence("dof"), "ㄉㄡˇ");
  XCTAssertEqual(composer.cnvSequence("doj"), "ㄉㄡˋ");
  XCTAssertEqual(composer.cnvSequence("dm"), "ㄉㄢ");
  XCTAssertEqual(composer.cnvSequence("dmf"), "ㄉㄢˇ");
  XCTAssertEqual(composer.cnvSequence("dmj"), "ㄉㄢˋ");
  XCTAssertEqual(composer.cnvSequence("dnj"), "ㄉㄣˋ");
  XCTAssertEqual(composer.cnvSequence("dk"), "ㄉㄤ");
  XCTAssertEqual(composer.cnvSequence("dkf"), "ㄉㄤˇ");
  XCTAssertEqual(composer.cnvSequence("dkj"), "ㄉㄤˋ");
  XCTAssertEqual(composer.cnvSequence("dl"), "ㄉㄥ");
  XCTAssertEqual(composer.cnvSequence("dlf"), "ㄉㄥˇ");
  XCTAssertEqual(composer.cnvSequence("dlj"), "ㄉㄥˋ");
  XCTAssertEqual(composer.cnvSequence("de"), "ㄉㄧ");
  XCTAssertEqual(composer.cnvSequence("ded"), "ㄉㄧˊ");
  XCTAssertEqual(composer.cnvSequence("def"), "ㄉㄧˇ");
  XCTAssertEqual(composer.cnvSequence("dej"), "ㄉㄧˋ");
  XCTAssertEqual(composer.cnvSequence("deyf"), "ㄉㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("dee"), "ㄉㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("deed"), "ㄉㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("deef"), "ㄉㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("deej"), "ㄉㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("dew"), "ㄉㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("dewf"), "ㄉㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("dewj"), "ㄉㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("deo"), "ㄉㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("dem"), "ㄉㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("demd"), "ㄉㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("demf"), "ㄉㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("demj"), "ㄉㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("del"), "ㄉㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("deld"), "ㄉㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("delf"), "ㄉㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("delj"), "ㄉㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("dx"), "ㄉㄨ");
  XCTAssertEqual(composer.cnvSequence("dxd"), "ㄉㄨˊ");
  XCTAssertEqual(composer.cnvSequence("dxf"), "ㄉㄨˇ");
  XCTAssertEqual(composer.cnvSequence("dxj"), "ㄉㄨˋ");
  XCTAssertEqual(composer.cnvSequence("dxh"), "ㄉㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("dxhd"), "ㄉㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("dxhf"), "ㄉㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("dxhj"), "ㄉㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("dxhs"), "ㄉㄨㄛ˙");
  XCTAssertEqual(composer.cnvSequence("dxa"), "ㄉㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("dxaf"), "ㄉㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("dxaj"), "ㄉㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("dxm"), "ㄉㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("dxmf"), "ㄉㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("dxmj"), "ㄉㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("dxn"), "ㄉㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("dxnf"), "ㄉㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("dxnj"), "ㄉㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("dxl"), "ㄉㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("dxlf"), "ㄉㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("dxlj"), "ㄉㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ty"), "ㄊㄚ");
  XCTAssertEqual(composer.cnvSequence("tyf"), "ㄊㄚˇ");
  XCTAssertEqual(composer.cnvSequence("tyj"), "ㄊㄚˋ");
  XCTAssertEqual(composer.cnvSequence("tgj"), "ㄊㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ti"), "ㄊㄞ");
  XCTAssertEqual(composer.cnvSequence("tid"), "ㄊㄞˊ");
  XCTAssertEqual(composer.cnvSequence("tif"), "ㄊㄞˇ");
  XCTAssertEqual(composer.cnvSequence("tij"), "ㄊㄞˋ");
  XCTAssertEqual(composer.cnvSequence("tis"), "ㄊㄞ˙");
  XCTAssertEqual(composer.cnvSequence("tw"), "ㄊㄠ");
  XCTAssertEqual(composer.cnvSequence("twd"), "ㄊㄠˊ");
  XCTAssertEqual(composer.cnvSequence("twf"), "ㄊㄠˇ");
  XCTAssertEqual(composer.cnvSequence("twj"), "ㄊㄠˋ");
  XCTAssertEqual(composer.cnvSequence("tws"), "ㄊㄠ˙");
  XCTAssertEqual(composer.cnvSequence("to"), "ㄊㄡ");
  XCTAssertEqual(composer.cnvSequence("tod"), "ㄊㄡˊ");
  XCTAssertEqual(composer.cnvSequence("tof"), "ㄊㄡˇ");
  XCTAssertEqual(composer.cnvSequence("toj"), "ㄊㄡˋ");
  XCTAssertEqual(composer.cnvSequence("tos"), "ㄊㄡ˙");
  XCTAssertEqual(composer.cnvSequence("tm"), "ㄊㄢ");
  XCTAssertEqual(composer.cnvSequence("tmd"), "ㄊㄢˊ");
  XCTAssertEqual(composer.cnvSequence("tmf"), "ㄊㄢˇ");
  XCTAssertEqual(composer.cnvSequence("tmj"), "ㄊㄢˋ");
  XCTAssertEqual(composer.cnvSequence("tk"), "ㄊㄤ");
  XCTAssertEqual(composer.cnvSequence("tkd"), "ㄊㄤˊ");
  XCTAssertEqual(composer.cnvSequence("tkf"), "ㄊㄤˇ");
  XCTAssertEqual(composer.cnvSequence("tkj"), "ㄊㄤˋ");
  XCTAssertEqual(composer.cnvSequence("tl"), "ㄊㄥ");
  XCTAssertEqual(composer.cnvSequence("tld"), "ㄊㄥˊ");
  XCTAssertEqual(composer.cnvSequence("tlj"), "ㄊㄥˋ");
  XCTAssertEqual(composer.cnvSequence("te"), "ㄊㄧ");
  XCTAssertEqual(composer.cnvSequence("ted"), "ㄊㄧˊ");
  XCTAssertEqual(composer.cnvSequence("tef"), "ㄊㄧˇ");
  XCTAssertEqual(composer.cnvSequence("tej"), "ㄊㄧˋ");
  XCTAssertEqual(composer.cnvSequence("tee"), "ㄊㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("teed"), "ㄊㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("teef"), "ㄊㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("teej"), "ㄊㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("tew"), "ㄊㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("tewd"), "ㄊㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("tewf"), "ㄊㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("tewj"), "ㄊㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("tem"), "ㄊㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("temd"), "ㄊㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("temf"), "ㄊㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("temj"), "ㄊㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("tel"), "ㄊㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("teld"), "ㄊㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("telf"), "ㄊㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("telj"), "ㄊㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("tx"), "ㄊㄨ");
  XCTAssertEqual(composer.cnvSequence("txd"), "ㄊㄨˊ");
  XCTAssertEqual(composer.cnvSequence("txf"), "ㄊㄨˇ");
  XCTAssertEqual(composer.cnvSequence("txj"), "ㄊㄨˋ");
  XCTAssertEqual(composer.cnvSequence("txh"), "ㄊㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("txhd"), "ㄊㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("txhf"), "ㄊㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("txhj"), "ㄊㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("txa"), "ㄊㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("txad"), "ㄊㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("txaf"), "ㄊㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("txaj"), "ㄊㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("txm"), "ㄊㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("txmd"), "ㄊㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("txmf"), "ㄊㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("txmj"), "ㄊㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("txn"), "ㄊㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("txnd"), "ㄊㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("txnf"), "ㄊㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("txnj"), "ㄊㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("txl"), "ㄊㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("txld"), "ㄊㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("txlf"), "ㄊㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("txlj"), "ㄊㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ny"), "ㄋㄚ");
  XCTAssertEqual(composer.cnvSequence("nyd"), "ㄋㄚˊ");
  XCTAssertEqual(composer.cnvSequence("nyf"), "ㄋㄚˇ");
  XCTAssertEqual(composer.cnvSequence("nyj"), "ㄋㄚˋ");
  XCTAssertEqual(composer.cnvSequence("nys"), "ㄋㄚ˙");
  XCTAssertEqual(composer.cnvSequence("ngj"), "ㄋㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ngs"), "ㄋㄜ˙");
  XCTAssertEqual(composer.cnvSequence("nid"), "ㄋㄞˊ");
  XCTAssertEqual(composer.cnvSequence("nif"), "ㄋㄞˇ");
  XCTAssertEqual(composer.cnvSequence("nij"), "ㄋㄞˋ");
  XCTAssertEqual(composer.cnvSequence("nad"), "ㄋㄟˊ");
  XCTAssertEqual(composer.cnvSequence("naf"), "ㄋㄟˇ");
  XCTAssertEqual(composer.cnvSequence("naj"), "ㄋㄟˋ");
  XCTAssertEqual(composer.cnvSequence("nw"), "ㄋㄠ");
  XCTAssertEqual(composer.cnvSequence("nwd"), "ㄋㄠˊ");
  XCTAssertEqual(composer.cnvSequence("nwf"), "ㄋㄠˇ");
  XCTAssertEqual(composer.cnvSequence("nwj"), "ㄋㄠˋ");
  XCTAssertEqual(composer.cnvSequence("nod"), "ㄋㄡˊ");
  XCTAssertEqual(composer.cnvSequence("nof"), "ㄋㄡˇ");
  XCTAssertEqual(composer.cnvSequence("noj"), "ㄋㄡˋ");
  XCTAssertEqual(composer.cnvSequence("nm"), "ㄋㄢ");
  XCTAssertEqual(composer.cnvSequence("nmd"), "ㄋㄢˊ");
  XCTAssertEqual(composer.cnvSequence("nmf"), "ㄋㄢˇ");
  XCTAssertEqual(composer.cnvSequence("nmj"), "ㄋㄢˋ");
  XCTAssertEqual(composer.cnvSequence("nnf"), "ㄋㄣˇ");
  XCTAssertEqual(composer.cnvSequence("nnj"), "ㄋㄣˋ");
  XCTAssertEqual(composer.cnvSequence("nk"), "ㄋㄤ");
  XCTAssertEqual(composer.cnvSequence("nkd"), "ㄋㄤˊ");
  XCTAssertEqual(composer.cnvSequence("nkf"), "ㄋㄤˇ");
  XCTAssertEqual(composer.cnvSequence("nkj"), "ㄋㄤˋ");
  XCTAssertEqual(composer.cnvSequence("nks"), "ㄋㄤ˙");
  XCTAssertEqual(composer.cnvSequence("nld"), "ㄋㄥˊ");
  XCTAssertEqual(composer.cnvSequence("nlf"), "ㄋㄥˇ");
  XCTAssertEqual(composer.cnvSequence("ne"), "ㄋㄧ");
  XCTAssertEqual(composer.cnvSequence("ned"), "ㄋㄧˊ");
  XCTAssertEqual(composer.cnvSequence("nef"), "ㄋㄧˇ");
  XCTAssertEqual(composer.cnvSequence("nej"), "ㄋㄧˋ");
  XCTAssertEqual(composer.cnvSequence("nee"), "ㄋㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("need"), "ㄋㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("neej"), "ㄋㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("newf"), "ㄋㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("newj"), "ㄋㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("neo"), "ㄋㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("neod"), "ㄋㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("neof"), "ㄋㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("neoj"), "ㄋㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("nem"), "ㄋㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("nemd"), "ㄋㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("nemf"), "ㄋㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("nemj"), "ㄋㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("nen"), "ㄋㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("nend"), "ㄋㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("nenf"), "ㄋㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("nenj"), "ㄋㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("nekd"), "ㄋㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("nekf"), "ㄋㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("nekj"), "ㄋㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("neld"), "ㄋㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("nelf"), "ㄋㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("nelj"), "ㄋㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("nxd"), "ㄋㄨˊ");
  XCTAssertEqual(composer.cnvSequence("nxf"), "ㄋㄨˇ");
  XCTAssertEqual(composer.cnvSequence("nxj"), "ㄋㄨˋ");
  XCTAssertEqual(composer.cnvSequence("nxhd"), "ㄋㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("nxhf"), "ㄋㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("nxhj"), "ㄋㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("nxad"), "ㄋㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("nxmd"), "ㄋㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("nxmf"), "ㄋㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("nxmj"), "ㄋㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("nxnd"), "ㄋㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("nxld"), "ㄋㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("nxlf"), "ㄋㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("nxlj"), "ㄋㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("nud"), "ㄋㄩˊ");
  XCTAssertEqual(composer.cnvSequence("nuf"), "ㄋㄩˇ");
  XCTAssertEqual(composer.cnvSequence("nuj"), "ㄋㄩˋ");
  XCTAssertEqual(composer.cnvSequence("nuej"), "ㄋㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("ly"), "ㄌㄚ");
  XCTAssertEqual(composer.cnvSequence("lyd"), "ㄌㄚˊ");
  XCTAssertEqual(composer.cnvSequence("lyf"), "ㄌㄚˇ");
  XCTAssertEqual(composer.cnvSequence("lyj"), "ㄌㄚˋ");
  XCTAssertEqual(composer.cnvSequence("lys"), "ㄌㄚ˙");
  XCTAssertEqual(composer.cnvSequence("lh"), "ㄌㄛ");
  XCTAssertEqual(composer.cnvSequence("lhs"), "ㄌㄛ˙");
  XCTAssertEqual(composer.cnvSequence("lg"), "ㄌㄜ");
  XCTAssertEqual(composer.cnvSequence("lgd"), "ㄌㄜˊ");
  XCTAssertEqual(composer.cnvSequence("lgj"), "ㄌㄜˋ");
  XCTAssertEqual(composer.cnvSequence("lgs"), "ㄌㄜ˙");
  XCTAssertEqual(composer.cnvSequence("lid"), "ㄌㄞˊ");
  XCTAssertEqual(composer.cnvSequence("lif"), "ㄌㄞˇ");
  XCTAssertEqual(composer.cnvSequence("lij"), "ㄌㄞˋ");
  XCTAssertEqual(composer.cnvSequence("la"), "ㄌㄟ");
  XCTAssertEqual(composer.cnvSequence("lad"), "ㄌㄟˊ");
  XCTAssertEqual(composer.cnvSequence("laf"), "ㄌㄟˇ");
  XCTAssertEqual(composer.cnvSequence("laj"), "ㄌㄟˋ");
  XCTAssertEqual(composer.cnvSequence("las"), "ㄌㄟ˙");
  XCTAssertEqual(composer.cnvSequence("lw"), "ㄌㄠ");
  XCTAssertEqual(composer.cnvSequence("lwd"), "ㄌㄠˊ");
  XCTAssertEqual(composer.cnvSequence("lwf"), "ㄌㄠˇ");
  XCTAssertEqual(composer.cnvSequence("lwj"), "ㄌㄠˋ");
  XCTAssertEqual(composer.cnvSequence("lo"), "ㄌㄡ");
  XCTAssertEqual(composer.cnvSequence("lod"), "ㄌㄡˊ");
  XCTAssertEqual(composer.cnvSequence("lof"), "ㄌㄡˇ");
  XCTAssertEqual(composer.cnvSequence("loj"), "ㄌㄡˋ");
  XCTAssertEqual(composer.cnvSequence("los"), "ㄌㄡ˙");
  XCTAssertEqual(composer.cnvSequence("lmd"), "ㄌㄢˊ");
  XCTAssertEqual(composer.cnvSequence("lmf"), "ㄌㄢˇ");
  XCTAssertEqual(composer.cnvSequence("lmj"), "ㄌㄢˋ");
  XCTAssertEqual(composer.cnvSequence("lk"), "ㄌㄤ");
  XCTAssertEqual(composer.cnvSequence("lkd"), "ㄌㄤˊ");
  XCTAssertEqual(composer.cnvSequence("lkf"), "ㄌㄤˇ");
  XCTAssertEqual(composer.cnvSequence("lkj"), "ㄌㄤˋ");
  XCTAssertEqual(composer.cnvSequence("ll"), "ㄌㄥ");
  XCTAssertEqual(composer.cnvSequence("lld"), "ㄌㄥˊ");
  XCTAssertEqual(composer.cnvSequence("llf"), "ㄌㄥˇ");
  XCTAssertEqual(composer.cnvSequence("llj"), "ㄌㄥˋ");
  XCTAssertEqual(composer.cnvSequence("le"), "ㄌㄧ");
  XCTAssertEqual(composer.cnvSequence("led"), "ㄌㄧˊ");
  XCTAssertEqual(composer.cnvSequence("lef"), "ㄌㄧˇ");
  XCTAssertEqual(composer.cnvSequence("lej"), "ㄌㄧˋ");
  XCTAssertEqual(composer.cnvSequence("les"), "ㄌㄧ˙");
  XCTAssertEqual(composer.cnvSequence("leyf"), "ㄌㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("lee"), "ㄌㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("leed"), "ㄌㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("leef"), "ㄌㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("leej"), "ㄌㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("lew"), "ㄌㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("lewd"), "ㄌㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("lewf"), "ㄌㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("lewj"), "ㄌㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("leo"), "ㄌㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("leod"), "ㄌㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("leof"), "ㄌㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("leoj"), "ㄌㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("lem"), "ㄌㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("lemd"), "ㄌㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("lemf"), "ㄌㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("lemj"), "ㄌㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("lend"), "ㄌㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("lenf"), "ㄌㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("lenj"), "ㄌㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("lekd"), "ㄌㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("lekf"), "ㄌㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("lekj"), "ㄌㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("lel"), "ㄌㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("leld"), "ㄌㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("lelf"), "ㄌㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("lelj"), "ㄌㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("lx"), "ㄌㄨ");
  XCTAssertEqual(composer.cnvSequence("lxd"), "ㄌㄨˊ");
  XCTAssertEqual(composer.cnvSequence("lxf"), "ㄌㄨˇ");
  XCTAssertEqual(composer.cnvSequence("lxj"), "ㄌㄨˋ");
  XCTAssertEqual(composer.cnvSequence("lxh"), "ㄌㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("lxhd"), "ㄌㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("lxhf"), "ㄌㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("lxhj"), "ㄌㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("lxhs"), "ㄌㄨㄛ˙");
  XCTAssertEqual(composer.cnvSequence("lxmd"), "ㄌㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("lxmf"), "ㄌㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("lxmj"), "ㄌㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("lxn"), "ㄌㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("lxnd"), "ㄌㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("lxnf"), "ㄌㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("lxnj"), "ㄌㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("lxl"), "ㄌㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("lxld"), "ㄌㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("lxlf"), "ㄌㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("lxlj"), "ㄌㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("lu"), "ㄌㄩ");
  XCTAssertEqual(composer.cnvSequence("lud"), "ㄌㄩˊ");
  XCTAssertEqual(composer.cnvSequence("luf"), "ㄌㄩˇ");
  XCTAssertEqual(composer.cnvSequence("luj"), "ㄌㄩˋ");
  XCTAssertEqual(composer.cnvSequence("lue"), "ㄌㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("luef"), "ㄌㄩㄝˇ");
  XCTAssertEqual(composer.cnvSequence("luej"), "ㄌㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("lumd"), "ㄌㄩㄢˊ");
  XCTAssertEqual(composer.cnvSequence("lumf"), "ㄌㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("gy"), "ㄍㄚ");
  XCTAssertEqual(composer.cnvSequence("gyd"), "ㄍㄚˊ");
  XCTAssertEqual(composer.cnvSequence("gyf"), "ㄍㄚˇ");
  XCTAssertEqual(composer.cnvSequence("gyj"), "ㄍㄚˋ");
  XCTAssertEqual(composer.cnvSequence("gys"), "ㄍㄚ˙");
  XCTAssertEqual(composer.cnvSequence("gg"), "ㄍㄜ");
  XCTAssertEqual(composer.cnvSequence("ggd"), "ㄍㄜˊ");
  XCTAssertEqual(composer.cnvSequence("ggf"), "ㄍㄜˇ");
  XCTAssertEqual(composer.cnvSequence("ggj"), "ㄍㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ggs"), "ㄍㄜ˙");
  XCTAssertEqual(composer.cnvSequence("gi"), "ㄍㄞ");
  XCTAssertEqual(composer.cnvSequence("gif"), "ㄍㄞˇ");
  XCTAssertEqual(composer.cnvSequence("gij"), "ㄍㄞˋ");
  XCTAssertEqual(composer.cnvSequence("gaf"), "ㄍㄟˇ");
  XCTAssertEqual(composer.cnvSequence("gw"), "ㄍㄠ");
  XCTAssertEqual(composer.cnvSequence("gwf"), "ㄍㄠˇ");
  XCTAssertEqual(composer.cnvSequence("gwj"), "ㄍㄠˋ");
  XCTAssertEqual(composer.cnvSequence("go"), "ㄍㄡ");
  XCTAssertEqual(composer.cnvSequence("gof"), "ㄍㄡˇ");
  XCTAssertEqual(composer.cnvSequence("goj"), "ㄍㄡˋ");
  XCTAssertEqual(composer.cnvSequence("gm"), "ㄍㄢ");
  XCTAssertEqual(composer.cnvSequence("gmf"), "ㄍㄢˇ");
  XCTAssertEqual(composer.cnvSequence("gmj"), "ㄍㄢˋ");
  XCTAssertEqual(composer.cnvSequence("gn"), "ㄍㄣ");
  XCTAssertEqual(composer.cnvSequence("gnd"), "ㄍㄣˊ");
  XCTAssertEqual(composer.cnvSequence("gnf"), "ㄍㄣˇ");
  XCTAssertEqual(composer.cnvSequence("gnj"), "ㄍㄣˋ");
  XCTAssertEqual(composer.cnvSequence("gk"), "ㄍㄤ");
  XCTAssertEqual(composer.cnvSequence("gkf"), "ㄍㄤˇ");
  XCTAssertEqual(composer.cnvSequence("gkj"), "ㄍㄤˋ");
  XCTAssertEqual(composer.cnvSequence("gl"), "ㄍㄥ");
  XCTAssertEqual(composer.cnvSequence("glf"), "ㄍㄥˇ");
  XCTAssertEqual(composer.cnvSequence("glj"), "ㄍㄥˋ");
  XCTAssertEqual(composer.cnvSequence("gx"), "ㄍㄨ");
  XCTAssertEqual(composer.cnvSequence("gxd"), "ㄍㄨˊ");
  XCTAssertEqual(composer.cnvSequence("gxf"), "ㄍㄨˇ");
  XCTAssertEqual(composer.cnvSequence("gxj"), "ㄍㄨˋ");
  XCTAssertEqual(composer.cnvSequence("gxy"), "ㄍㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("gxyd"), "ㄍㄨㄚˊ");
  XCTAssertEqual(composer.cnvSequence("gxyf"), "ㄍㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("gxyj"), "ㄍㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("gxh"), "ㄍㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("gxhd"), "ㄍㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("gxhf"), "ㄍㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("gxhj"), "ㄍㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("gxgd"), "ㄍㄨㄜˊ");
  XCTAssertEqual(composer.cnvSequence("gxi"), "ㄍㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("gxif"), "ㄍㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("gxij"), "ㄍㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("gxa"), "ㄍㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("gxaf"), "ㄍㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("gxaj"), "ㄍㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("gxm"), "ㄍㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("gxmf"), "ㄍㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("gxmj"), "ㄍㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("gxn"), "ㄍㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("gxnf"), "ㄍㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("gxnj"), "ㄍㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("gxk"), "ㄍㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("gxkf"), "ㄍㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("gxkj"), "ㄍㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("gxl"), "ㄍㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("gxld"), "ㄍㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("gxlf"), "ㄍㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("gxlj"), "ㄍㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ky"), "ㄎㄚ");
  XCTAssertEqual(composer.cnvSequence("kyf"), "ㄎㄚˇ");
  XCTAssertEqual(composer.cnvSequence("kyj"), "ㄎㄚˋ");
  XCTAssertEqual(composer.cnvSequence("kg"), "ㄎㄜ");
  XCTAssertEqual(composer.cnvSequence("kgd"), "ㄎㄜˊ");
  XCTAssertEqual(composer.cnvSequence("kgf"), "ㄎㄜˇ");
  XCTAssertEqual(composer.cnvSequence("kgj"), "ㄎㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ki"), "ㄎㄞ");
  XCTAssertEqual(composer.cnvSequence("kif"), "ㄎㄞˇ");
  XCTAssertEqual(composer.cnvSequence("kij"), "ㄎㄞˋ");
  XCTAssertEqual(composer.cnvSequence("kw"), "ㄎㄠ");
  XCTAssertEqual(composer.cnvSequence("kwf"), "ㄎㄠˇ");
  XCTAssertEqual(composer.cnvSequence("kwj"), "ㄎㄠˋ");
  XCTAssertEqual(composer.cnvSequence("ko"), "ㄎㄡ");
  XCTAssertEqual(composer.cnvSequence("kof"), "ㄎㄡˇ");
  XCTAssertEqual(composer.cnvSequence("koj"), "ㄎㄡˋ");
  XCTAssertEqual(composer.cnvSequence("km"), "ㄎㄢ");
  XCTAssertEqual(composer.cnvSequence("kmf"), "ㄎㄢˇ");
  XCTAssertEqual(composer.cnvSequence("kmj"), "ㄎㄢˋ");
  XCTAssertEqual(composer.cnvSequence("kn"), "ㄎㄣ");
  XCTAssertEqual(composer.cnvSequence("knf"), "ㄎㄣˇ");
  XCTAssertEqual(composer.cnvSequence("knj"), "ㄎㄣˋ");
  XCTAssertEqual(composer.cnvSequence("kk"), "ㄎㄤ");
  XCTAssertEqual(composer.cnvSequence("kkd"), "ㄎㄤˊ");
  XCTAssertEqual(composer.cnvSequence("kkf"), "ㄎㄤˇ");
  XCTAssertEqual(composer.cnvSequence("kkj"), "ㄎㄤˋ");
  XCTAssertEqual(composer.cnvSequence("kl"), "ㄎㄥ");
  XCTAssertEqual(composer.cnvSequence("klf"), "ㄎㄥˇ");
  XCTAssertEqual(composer.cnvSequence("kx"), "ㄎㄨ");
  XCTAssertEqual(composer.cnvSequence("kxd"), "ㄎㄨˊ");
  XCTAssertEqual(composer.cnvSequence("kxf"), "ㄎㄨˇ");
  XCTAssertEqual(composer.cnvSequence("kxj"), "ㄎㄨˋ");
  XCTAssertEqual(composer.cnvSequence("kxy"), "ㄎㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("kxyf"), "ㄎㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("kxyj"), "ㄎㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("kxhj"), "ㄎㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("kxi"), "ㄎㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("kxif"), "ㄎㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("kxij"), "ㄎㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("kxa"), "ㄎㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("kxad"), "ㄎㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("kxaf"), "ㄎㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("kxaj"), "ㄎㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("kxm"), "ㄎㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("kxmf"), "ㄎㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("kxmj"), "ㄎㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("kxn"), "ㄎㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("kxnf"), "ㄎㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("kxnj"), "ㄎㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("kxk"), "ㄎㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("kxkd"), "ㄎㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("kxkf"), "ㄎㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("kxkj"), "ㄎㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("kxl"), "ㄎㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("kxlf"), "ㄎㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("kxlj"), "ㄎㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("hy"), "ㄏㄚ");
  XCTAssertEqual(composer.cnvSequence("hyd"), "ㄏㄚˊ");
  XCTAssertEqual(composer.cnvSequence("hyf"), "ㄏㄚˇ");
  XCTAssertEqual(composer.cnvSequence("hg"), "ㄏㄜ");
  XCTAssertEqual(composer.cnvSequence("hgd"), "ㄏㄜˊ");
  XCTAssertEqual(composer.cnvSequence("hgf"), "ㄏㄜˇ");
  XCTAssertEqual(composer.cnvSequence("hgj"), "ㄏㄜˋ");
  XCTAssertEqual(composer.cnvSequence("hi"), "ㄏㄞ");
  XCTAssertEqual(composer.cnvSequence("hid"), "ㄏㄞˊ");
  XCTAssertEqual(composer.cnvSequence("hif"), "ㄏㄞˇ");
  XCTAssertEqual(composer.cnvSequence("hij"), "ㄏㄞˋ");
  XCTAssertEqual(composer.cnvSequence("ha"), "ㄏㄟ");
  XCTAssertEqual(composer.cnvSequence("haf"), "ㄏㄟˇ");
  XCTAssertEqual(composer.cnvSequence("hw"), "ㄏㄠ");
  XCTAssertEqual(composer.cnvSequence("hwd"), "ㄏㄠˊ");
  XCTAssertEqual(composer.cnvSequence("hwf"), "ㄏㄠˇ");
  XCTAssertEqual(composer.cnvSequence("hwj"), "ㄏㄠˋ");
  XCTAssertEqual(composer.cnvSequence("ho"), "ㄏㄡ");
  XCTAssertEqual(composer.cnvSequence("hod"), "ㄏㄡˊ");
  XCTAssertEqual(composer.cnvSequence("hof"), "ㄏㄡˇ");
  XCTAssertEqual(composer.cnvSequence("hoj"), "ㄏㄡˋ");
  XCTAssertEqual(composer.cnvSequence("hm"), "ㄏㄢ");
  XCTAssertEqual(composer.cnvSequence("hmd"), "ㄏㄢˊ");
  XCTAssertEqual(composer.cnvSequence("hmf"), "ㄏㄢˇ");
  XCTAssertEqual(composer.cnvSequence("hmj"), "ㄏㄢˋ");
  XCTAssertEqual(composer.cnvSequence("hn"), "ㄏㄣ");
  XCTAssertEqual(composer.cnvSequence("hnd"), "ㄏㄣˊ");
  XCTAssertEqual(composer.cnvSequence("hnf"), "ㄏㄣˇ");
  XCTAssertEqual(composer.cnvSequence("hnj"), "ㄏㄣˋ");
  XCTAssertEqual(composer.cnvSequence("hk"), "ㄏㄤ");
  XCTAssertEqual(composer.cnvSequence("hkd"), "ㄏㄤˊ");
  XCTAssertEqual(composer.cnvSequence("hkf"), "ㄏㄤˇ");
  XCTAssertEqual(composer.cnvSequence("hkj"), "ㄏㄤˋ");
  XCTAssertEqual(composer.cnvSequence("hl"), "ㄏㄥ");
  XCTAssertEqual(composer.cnvSequence("hld"), "ㄏㄥˊ");
  XCTAssertEqual(composer.cnvSequence("hlj"), "ㄏㄥˋ");
  XCTAssertEqual(composer.cnvSequence("hx"), "ㄏㄨ");
  XCTAssertEqual(composer.cnvSequence("hxd"), "ㄏㄨˊ");
  XCTAssertEqual(composer.cnvSequence("hxf"), "ㄏㄨˇ");
  XCTAssertEqual(composer.cnvSequence("hxj"), "ㄏㄨˋ");
  XCTAssertEqual(composer.cnvSequence("hxy"), "ㄏㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("hxyd"), "ㄏㄨㄚˊ");
  XCTAssertEqual(composer.cnvSequence("hxyf"), "ㄏㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("hxyj"), "ㄏㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("hxh"), "ㄏㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("hxhd"), "ㄏㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("hxhf"), "ㄏㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("hxhj"), "ㄏㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("hxhs"), "ㄏㄨㄛ˙");
  XCTAssertEqual(composer.cnvSequence("hxid"), "ㄏㄨㄞˊ");
  XCTAssertEqual(composer.cnvSequence("hxij"), "ㄏㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("hxa"), "ㄏㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("hxad"), "ㄏㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("hxaf"), "ㄏㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("hxaj"), "ㄏㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("hxm"), "ㄏㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("hxmd"), "ㄏㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("hxmf"), "ㄏㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("hxmj"), "ㄏㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("hxn"), "ㄏㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("hxnd"), "ㄏㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("hxnf"), "ㄏㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("hxnj"), "ㄏㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("hxk"), "ㄏㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("hxkd"), "ㄏㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("hxkf"), "ㄏㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("hxkj"), "ㄏㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("hxks"), "ㄏㄨㄤ˙");
  XCTAssertEqual(composer.cnvSequence("hxl"), "ㄏㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("hxld"), "ㄏㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("hxlf"), "ㄏㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("hxlj"), "ㄏㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("je"), "ㄐㄧ");
  XCTAssertEqual(composer.cnvSequence("jed"), "ㄐㄧˊ");
  XCTAssertEqual(composer.cnvSequence("jef"), "ㄐㄧˇ");
  XCTAssertEqual(composer.cnvSequence("jej"), "ㄐㄧˋ");
  XCTAssertEqual(composer.cnvSequence("jey"), "ㄐㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("jeyd"), "ㄐㄧㄚˊ");
  XCTAssertEqual(composer.cnvSequence("jeyf"), "ㄐㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("jeyj"), "ㄐㄧㄚˋ");
  XCTAssertEqual(composer.cnvSequence("jee"), "ㄐㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("jeed"), "ㄐㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("jeef"), "ㄐㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("jeej"), "ㄐㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("jees"), "ㄐㄧㄝ˙");
  XCTAssertEqual(composer.cnvSequence("jew"), "ㄐㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("jewd"), "ㄐㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("jewf"), "ㄐㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("jewj"), "ㄐㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("jeo"), "ㄐㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("jeof"), "ㄐㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("jeoj"), "ㄐㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("jem"), "ㄐㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("jemf"), "ㄐㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("jemj"), "ㄐㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("jen"), "ㄐㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("jenf"), "ㄐㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("jenj"), "ㄐㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("jek"), "ㄐㄧㄤ");
  XCTAssertEqual(composer.cnvSequence("jekd"), "ㄐㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("jekf"), "ㄐㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("jekj"), "ㄐㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("jel"), "ㄐㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("jelf"), "ㄐㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("jelj"), "ㄐㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ju"), "ㄐㄩ");
  XCTAssertEqual(composer.cnvSequence("jud"), "ㄐㄩˊ");
  XCTAssertEqual(composer.cnvSequence("juf"), "ㄐㄩˇ");
  XCTAssertEqual(composer.cnvSequence("juj"), "ㄐㄩˋ");
  XCTAssertEqual(composer.cnvSequence("jue"), "ㄐㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("jued"), "ㄐㄩㄝˊ");
  XCTAssertEqual(composer.cnvSequence("juef"), "ㄐㄩㄝˇ");
  XCTAssertEqual(composer.cnvSequence("juej"), "ㄐㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("jum"), "ㄐㄩㄢ");
  XCTAssertEqual(composer.cnvSequence("jumf"), "ㄐㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("jumj"), "ㄐㄩㄢˋ");
  XCTAssertEqual(composer.cnvSequence("jun"), "ㄐㄩㄣ");
  XCTAssertEqual(composer.cnvSequence("jund"), "ㄐㄩㄣˊ");
  XCTAssertEqual(composer.cnvSequence("junf"), "ㄐㄩㄣˇ");
  XCTAssertEqual(composer.cnvSequence("junj"), "ㄐㄩㄣˋ");
  XCTAssertEqual(composer.cnvSequence("jul"), "ㄐㄩㄥ");
  XCTAssertEqual(composer.cnvSequence("julf"), "ㄐㄩㄥˇ");
  XCTAssertEqual(composer.cnvSequence("julj"), "ㄐㄩㄥˋ");
  // XCTAssertEqual(composer.cnvSequence("vs"), "ㄑ˙");
  XCTAssertEqual(composer.cnvSequence("ve"), "ㄑㄧ");
  XCTAssertEqual(composer.cnvSequence("ved"), "ㄑㄧˊ");
  XCTAssertEqual(composer.cnvSequence("vef"), "ㄑㄧˇ");
  XCTAssertEqual(composer.cnvSequence("vej"), "ㄑㄧˋ");
  XCTAssertEqual(composer.cnvSequence("vey"), "ㄑㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("veyd"), "ㄑㄧㄚˊ");
  XCTAssertEqual(composer.cnvSequence("veyf"), "ㄑㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("veyj"), "ㄑㄧㄚˋ");
  XCTAssertEqual(composer.cnvSequence("vee"), "ㄑㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("veed"), "ㄑㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("veef"), "ㄑㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("veej"), "ㄑㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("vew"), "ㄑㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("vewd"), "ㄑㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("vewf"), "ㄑㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("vewj"), "ㄑㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("veo"), "ㄑㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("veod"), "ㄑㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("veof"), "ㄑㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("veoj"), "ㄑㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("vem"), "ㄑㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("vemd"), "ㄑㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("vemf"), "ㄑㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("vemj"), "ㄑㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("ven"), "ㄑㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("vend"), "ㄑㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("venf"), "ㄑㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("venj"), "ㄑㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("vek"), "ㄑㄧㄤ");
  XCTAssertEqual(composer.cnvSequence("vekd"), "ㄑㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("vekf"), "ㄑㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("vekj"), "ㄑㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("vel"), "ㄑㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("veld"), "ㄑㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("velf"), "ㄑㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("velj"), "ㄑㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("vu"), "ㄑㄩ");
  XCTAssertEqual(composer.cnvSequence("vud"), "ㄑㄩˊ");
  XCTAssertEqual(composer.cnvSequence("vuf"), "ㄑㄩˇ");
  XCTAssertEqual(composer.cnvSequence("vuj"), "ㄑㄩˋ");
  XCTAssertEqual(composer.cnvSequence("vue"), "ㄑㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("vued"), "ㄑㄩㄝˊ");
  XCTAssertEqual(composer.cnvSequence("vuej"), "ㄑㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("vum"), "ㄑㄩㄢ");
  XCTAssertEqual(composer.cnvSequence("vumd"), "ㄑㄩㄢˊ");
  XCTAssertEqual(composer.cnvSequence("vumf"), "ㄑㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("vumj"), "ㄑㄩㄢˋ");
  XCTAssertEqual(composer.cnvSequence("vun"), "ㄑㄩㄣ");
  XCTAssertEqual(composer.cnvSequence("vund"), "ㄑㄩㄣˊ");
  XCTAssertEqual(composer.cnvSequence("vunf"), "ㄑㄩㄣˇ");
  XCTAssertEqual(composer.cnvSequence("vunj"), "ㄑㄩㄣˋ");
  XCTAssertEqual(composer.cnvSequence("vul"), "ㄑㄩㄥ");
  XCTAssertEqual(composer.cnvSequence("vuld"), "ㄑㄩㄥˊ");
  XCTAssertEqual(composer.cnvSequence("vulf"), "ㄑㄩㄥˇ");
  XCTAssertEqual(composer.cnvSequence("vulj"), "ㄑㄩㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ce"), "ㄒㄧ");
  XCTAssertEqual(composer.cnvSequence("ced"), "ㄒㄧˊ");
  XCTAssertEqual(composer.cnvSequence("cef"), "ㄒㄧˇ");
  XCTAssertEqual(composer.cnvSequence("cej"), "ㄒㄧˋ");
  XCTAssertEqual(composer.cnvSequence("cey"), "ㄒㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("ceyd"), "ㄒㄧㄚˊ");
  XCTAssertEqual(composer.cnvSequence("ceyf"), "ㄒㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("ceyj"), "ㄒㄧㄚˋ");
  XCTAssertEqual(composer.cnvSequence("cee"), "ㄒㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("ceed"), "ㄒㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("ceef"), "ㄒㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("ceej"), "ㄒㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("cew"), "ㄒㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("cewd"), "ㄒㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("cewf"), "ㄒㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("cewj"), "ㄒㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("ceo"), "ㄒㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("ceod"), "ㄒㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("ceof"), "ㄒㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("ceoj"), "ㄒㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("cem"), "ㄒㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("cemd"), "ㄒㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("cemf"), "ㄒㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("cemj"), "ㄒㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("cen"), "ㄒㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("cend"), "ㄒㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("cenf"), "ㄒㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("cenj"), "ㄒㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("cek"), "ㄒㄧㄤ");
  XCTAssertEqual(composer.cnvSequence("cekd"), "ㄒㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("cekf"), "ㄒㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("cekj"), "ㄒㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("cel"), "ㄒㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("celd"), "ㄒㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("celf"), "ㄒㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("celj"), "ㄒㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("cu"), "ㄒㄩ");
  XCTAssertEqual(composer.cnvSequence("cud"), "ㄒㄩˊ");
  XCTAssertEqual(composer.cnvSequence("cuf"), "ㄒㄩˇ");
  XCTAssertEqual(composer.cnvSequence("cuj"), "ㄒㄩˋ");
  XCTAssertEqual(composer.cnvSequence("cue"), "ㄒㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("cued"), "ㄒㄩㄝˊ");
  XCTAssertEqual(composer.cnvSequence("cuef"), "ㄒㄩㄝˇ");
  XCTAssertEqual(composer.cnvSequence("cuej"), "ㄒㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("cum"), "ㄒㄩㄢ");
  XCTAssertEqual(composer.cnvSequence("cumd"), "ㄒㄩㄢˊ");
  XCTAssertEqual(composer.cnvSequence("cumf"), "ㄒㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("cumj"), "ㄒㄩㄢˋ");
  XCTAssertEqual(composer.cnvSequence("cun"), "ㄒㄩㄣ");
  XCTAssertEqual(composer.cnvSequence("cund"), "ㄒㄩㄣˊ");
  XCTAssertEqual(composer.cnvSequence("cunj"), "ㄒㄩㄣˋ");
  XCTAssertEqual(composer.cnvSequence("cul"), "ㄒㄩㄥ");
  XCTAssertEqual(composer.cnvSequence("culd"), "ㄒㄩㄥˊ");
  XCTAssertEqual(composer.cnvSequence("culf"), "ㄒㄩㄥˇ");
  XCTAssertEqual(composer.cnvSequence("culj"), "ㄒㄩㄥˋ");
  XCTAssertEqual(composer.cnvSequence("j"), "ㄓ");
  XCTAssertEqual(composer.cnvSequence("jd"), "ㄓˊ");
  XCTAssertEqual(composer.cnvSequence("jf"), "ㄓˇ");
  XCTAssertEqual(composer.cnvSequence("jj"), "ㄓˋ");
  XCTAssertEqual(composer.cnvSequence("jy"), "ㄓㄚ");
  XCTAssertEqual(composer.cnvSequence("jyd"), "ㄓㄚˊ");
  XCTAssertEqual(composer.cnvSequence("jyf"), "ㄓㄚˇ");
  XCTAssertEqual(composer.cnvSequence("jyj"), "ㄓㄚˋ");
  XCTAssertEqual(composer.cnvSequence("jg"), "ㄓㄜ");
  XCTAssertEqual(composer.cnvSequence("jgd"), "ㄓㄜˊ");
  XCTAssertEqual(composer.cnvSequence("jgf"), "ㄓㄜˇ");
  XCTAssertEqual(composer.cnvSequence("jgj"), "ㄓㄜˋ");
  XCTAssertEqual(composer.cnvSequence("jgs"), "ㄓㄜ˙");
  XCTAssertEqual(composer.cnvSequence("ji"), "ㄓㄞ");
  XCTAssertEqual(composer.cnvSequence("jid"), "ㄓㄞˊ");
  XCTAssertEqual(composer.cnvSequence("jif"), "ㄓㄞˇ");
  XCTAssertEqual(composer.cnvSequence("jij"), "ㄓㄞˋ");
  XCTAssertEqual(composer.cnvSequence("jaj"), "ㄓㄟˋ");
  XCTAssertEqual(composer.cnvSequence("jw"), "ㄓㄠ");
  XCTAssertEqual(composer.cnvSequence("jwd"), "ㄓㄠˊ");
  XCTAssertEqual(composer.cnvSequence("jwf"), "ㄓㄠˇ");
  XCTAssertEqual(composer.cnvSequence("jwj"), "ㄓㄠˋ");
  XCTAssertEqual(composer.cnvSequence("jo"), "ㄓㄡ");
  XCTAssertEqual(composer.cnvSequence("jod"), "ㄓㄡˊ");
  XCTAssertEqual(composer.cnvSequence("jof"), "ㄓㄡˇ");
  XCTAssertEqual(composer.cnvSequence("joj"), "ㄓㄡˋ");
  XCTAssertEqual(composer.cnvSequence("jm"), "ㄓㄢ");
  XCTAssertEqual(composer.cnvSequence("jmf"), "ㄓㄢˇ");
  XCTAssertEqual(composer.cnvSequence("jmj"), "ㄓㄢˋ");
  XCTAssertEqual(composer.cnvSequence("jn"), "ㄓㄣ");
  XCTAssertEqual(composer.cnvSequence("jnd"), "ㄓㄣˊ");
  XCTAssertEqual(composer.cnvSequence("jnf"), "ㄓㄣˇ");
  XCTAssertEqual(composer.cnvSequence("jnj"), "ㄓㄣˋ");
  XCTAssertEqual(composer.cnvSequence("jk"), "ㄓㄤ");
  XCTAssertEqual(composer.cnvSequence("jkf"), "ㄓㄤˇ");
  XCTAssertEqual(composer.cnvSequence("jkj"), "ㄓㄤˋ");
  XCTAssertEqual(composer.cnvSequence("jl"), "ㄓㄥ");
  XCTAssertEqual(composer.cnvSequence("jlf"), "ㄓㄥˇ");
  XCTAssertEqual(composer.cnvSequence("jlj"), "ㄓㄥˋ");
  XCTAssertEqual(composer.cnvSequence("jx"), "ㄓㄨ");
  XCTAssertEqual(composer.cnvSequence("jxd"), "ㄓㄨˊ");
  XCTAssertEqual(composer.cnvSequence("jxf"), "ㄓㄨˇ");
  XCTAssertEqual(composer.cnvSequence("jxj"), "ㄓㄨˋ");
  XCTAssertEqual(composer.cnvSequence("jxy"), "ㄓㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("jxyf"), "ㄓㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("jxh"), "ㄓㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("jxhd"), "ㄓㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("jxhj"), "ㄓㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("jxi"), "ㄓㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("jxif"), "ㄓㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("jxij"), "ㄓㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("jxa"), "ㄓㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("jxaf"), "ㄓㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("jxaj"), "ㄓㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("jxm"), "ㄓㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("jxmf"), "ㄓㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("jxmj"), "ㄓㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("jxn"), "ㄓㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("jxnf"), "ㄓㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("jxnj"), "ㄓㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("jxk"), "ㄓㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("jxkf"), "ㄓㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("jxkj"), "ㄓㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("jxl"), "ㄓㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("jxlf"), "ㄓㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("jxlj"), "ㄓㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("v"), "ㄔ");
  XCTAssertEqual(composer.cnvSequence("vd"), "ㄔˊ");
  XCTAssertEqual(composer.cnvSequence("vf"), "ㄔˇ");
  XCTAssertEqual(composer.cnvSequence("vj"), "ㄔˋ");
  XCTAssertEqual(composer.cnvSequence("vy"), "ㄔㄚ");
  XCTAssertEqual(composer.cnvSequence("vyd"), "ㄔㄚˊ");
  XCTAssertEqual(composer.cnvSequence("vyf"), "ㄔㄚˇ");
  XCTAssertEqual(composer.cnvSequence("vyj"), "ㄔㄚˋ");
  XCTAssertEqual(composer.cnvSequence("vg"), "ㄔㄜ");
  XCTAssertEqual(composer.cnvSequence("vgf"), "ㄔㄜˇ");
  XCTAssertEqual(composer.cnvSequence("vgj"), "ㄔㄜˋ");
  XCTAssertEqual(composer.cnvSequence("vi"), "ㄔㄞ");
  XCTAssertEqual(composer.cnvSequence("vid"), "ㄔㄞˊ");
  XCTAssertEqual(composer.cnvSequence("vif"), "ㄔㄞˇ");
  XCTAssertEqual(composer.cnvSequence("vij"), "ㄔㄞˋ");
  XCTAssertEqual(composer.cnvSequence("vw"), "ㄔㄠ");
  XCTAssertEqual(composer.cnvSequence("vwd"), "ㄔㄠˊ");
  XCTAssertEqual(composer.cnvSequence("vwf"), "ㄔㄠˇ");
  XCTAssertEqual(composer.cnvSequence("vwj"), "ㄔㄠˋ");
  XCTAssertEqual(composer.cnvSequence("vo"), "ㄔㄡ");
  XCTAssertEqual(composer.cnvSequence("vod"), "ㄔㄡˊ");
  XCTAssertEqual(composer.cnvSequence("vof"), "ㄔㄡˇ");
  XCTAssertEqual(composer.cnvSequence("voj"), "ㄔㄡˋ");
  XCTAssertEqual(composer.cnvSequence("vm"), "ㄔㄢ");
  XCTAssertEqual(composer.cnvSequence("vmd"), "ㄔㄢˊ");
  XCTAssertEqual(composer.cnvSequence("vmf"), "ㄔㄢˇ");
  XCTAssertEqual(composer.cnvSequence("vmj"), "ㄔㄢˋ");
  XCTAssertEqual(composer.cnvSequence("vn"), "ㄔㄣ");
  XCTAssertEqual(composer.cnvSequence("vnd"), "ㄔㄣˊ");
  XCTAssertEqual(composer.cnvSequence("vnf"), "ㄔㄣˇ");
  XCTAssertEqual(composer.cnvSequence("vnj"), "ㄔㄣˋ");
  XCTAssertEqual(composer.cnvSequence("vns"), "ㄔㄣ˙");
  XCTAssertEqual(composer.cnvSequence("vk"), "ㄔㄤ");
  XCTAssertEqual(composer.cnvSequence("vkd"), "ㄔㄤˊ");
  XCTAssertEqual(composer.cnvSequence("vkf"), "ㄔㄤˇ");
  XCTAssertEqual(composer.cnvSequence("vkj"), "ㄔㄤˋ");
  XCTAssertEqual(composer.cnvSequence("vl"), "ㄔㄥ");
  XCTAssertEqual(composer.cnvSequence("vld"), "ㄔㄥˊ");
  XCTAssertEqual(composer.cnvSequence("vlf"), "ㄔㄥˇ");
  XCTAssertEqual(composer.cnvSequence("vlj"), "ㄔㄥˋ");
  XCTAssertEqual(composer.cnvSequence("vx"), "ㄔㄨ");
  XCTAssertEqual(composer.cnvSequence("vxd"), "ㄔㄨˊ");
  XCTAssertEqual(composer.cnvSequence("vxf"), "ㄔㄨˇ");
  XCTAssertEqual(composer.cnvSequence("vxj"), "ㄔㄨˋ");
  XCTAssertEqual(composer.cnvSequence("vxy"), "ㄔㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("vxyf"), "ㄔㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("vxyj"), "ㄔㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("vxh"), "ㄔㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("vxhj"), "ㄔㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("vxi"), "ㄔㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("vxid"), "ㄔㄨㄞˊ");
  XCTAssertEqual(composer.cnvSequence("vxif"), "ㄔㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("vxij"), "ㄔㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("vxa"), "ㄔㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("vxad"), "ㄔㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("vxaf"), "ㄔㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("vxaj"), "ㄔㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("vxm"), "ㄔㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("vxmd"), "ㄔㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("vxmf"), "ㄔㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("vxmj"), "ㄔㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("vxn"), "ㄔㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("vxnd"), "ㄔㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("vxnf"), "ㄔㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("vxk"), "ㄔㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("vxkd"), "ㄔㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("vxkf"), "ㄔㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("vxkj"), "ㄔㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("vxl"), "ㄔㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("vxld"), "ㄔㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("vxlf"), "ㄔㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("vxlj"), "ㄔㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("c"), "ㄕ");
  XCTAssertEqual(composer.cnvSequence("cd"), "ㄕˊ");
  XCTAssertEqual(composer.cnvSequence("cf"), "ㄕˇ");
  XCTAssertEqual(composer.cnvSequence("cj"), "ㄕˋ");
  XCTAssertEqual(composer.cnvSequence("cs"), "ㄕ˙");
  XCTAssertEqual(composer.cnvSequence("cy"), "ㄕㄚ");
  XCTAssertEqual(composer.cnvSequence("cyd"), "ㄕㄚˊ");
  XCTAssertEqual(composer.cnvSequence("cyf"), "ㄕㄚˇ");
  XCTAssertEqual(composer.cnvSequence("cyj"), "ㄕㄚˋ");
  XCTAssertEqual(composer.cnvSequence("cys"), "ㄕㄚ˙");
  XCTAssertEqual(composer.cnvSequence("cg"), "ㄕㄜ");
  XCTAssertEqual(composer.cnvSequence("cgd"), "ㄕㄜˊ");
  XCTAssertEqual(composer.cnvSequence("cgf"), "ㄕㄜˇ");
  XCTAssertEqual(composer.cnvSequence("cgj"), "ㄕㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ci"), "ㄕㄞ");
  XCTAssertEqual(composer.cnvSequence("cif"), "ㄕㄞˇ");
  XCTAssertEqual(composer.cnvSequence("cij"), "ㄕㄞˋ");
  XCTAssertEqual(composer.cnvSequence("cad"), "ㄕㄟˊ");
  XCTAssertEqual(composer.cnvSequence("cw"), "ㄕㄠ");
  XCTAssertEqual(composer.cnvSequence("cwd"), "ㄕㄠˊ");
  XCTAssertEqual(composer.cnvSequence("cwf"), "ㄕㄠˇ");
  XCTAssertEqual(composer.cnvSequence("cwj"), "ㄕㄠˋ");
  XCTAssertEqual(composer.cnvSequence("co"), "ㄕㄡ");
  XCTAssertEqual(composer.cnvSequence("cod"), "ㄕㄡˊ");
  XCTAssertEqual(composer.cnvSequence("cof"), "ㄕㄡˇ");
  XCTAssertEqual(composer.cnvSequence("coj"), "ㄕㄡˋ");
  XCTAssertEqual(composer.cnvSequence("cm"), "ㄕㄢ");
  XCTAssertEqual(composer.cnvSequence("cmd"), "ㄕㄢˊ");
  XCTAssertEqual(composer.cnvSequence("cmf"), "ㄕㄢˇ");
  XCTAssertEqual(composer.cnvSequence("cmj"), "ㄕㄢˋ");
  XCTAssertEqual(composer.cnvSequence("cn"), "ㄕㄣ");
  XCTAssertEqual(composer.cnvSequence("cnd"), "ㄕㄣˊ");
  XCTAssertEqual(composer.cnvSequence("cnf"), "ㄕㄣˇ");
  XCTAssertEqual(composer.cnvSequence("cnj"), "ㄕㄣˋ");
  XCTAssertEqual(composer.cnvSequence("ck"), "ㄕㄤ");
  XCTAssertEqual(composer.cnvSequence("ckf"), "ㄕㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ckj"), "ㄕㄤˋ");
  XCTAssertEqual(composer.cnvSequence("cks"), "ㄕㄤ˙");
  XCTAssertEqual(composer.cnvSequence("cl"), "ㄕㄥ");
  XCTAssertEqual(composer.cnvSequence("cld"), "ㄕㄥˊ");
  XCTAssertEqual(composer.cnvSequence("clf"), "ㄕㄥˇ");
  XCTAssertEqual(composer.cnvSequence("clj"), "ㄕㄥˋ");
  XCTAssertEqual(composer.cnvSequence("cx"), "ㄕㄨ");
  XCTAssertEqual(composer.cnvSequence("cxd"), "ㄕㄨˊ");
  XCTAssertEqual(composer.cnvSequence("cxf"), "ㄕㄨˇ");
  XCTAssertEqual(composer.cnvSequence("cxj"), "ㄕㄨˋ");
  XCTAssertEqual(composer.cnvSequence("cxy"), "ㄕㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("cxyf"), "ㄕㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("cxyj"), "ㄕㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("cxh"), "ㄕㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("cxhj"), "ㄕㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("cxi"), "ㄕㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("cxif"), "ㄕㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("cxij"), "ㄕㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("cxa"), "ㄕㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("cxad"), "ㄕㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("cxaf"), "ㄕㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("cxaj"), "ㄕㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("cxm"), "ㄕㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("cxmj"), "ㄕㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("cxnf"), "ㄕㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("cxnj"), "ㄕㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("cxk"), "ㄕㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("cxkd"), "ㄕㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("cxkf"), "ㄕㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("cxkj"), "ㄕㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("rj"), "ㄖˋ");
  XCTAssertEqual(composer.cnvSequence("rgf"), "ㄖㄜˇ");
  XCTAssertEqual(composer.cnvSequence("rgj"), "ㄖㄜˋ");
  XCTAssertEqual(composer.cnvSequence("rwd"), "ㄖㄠˊ");
  XCTAssertEqual(composer.cnvSequence("rwf"), "ㄖㄠˇ");
  XCTAssertEqual(composer.cnvSequence("rwj"), "ㄖㄠˋ");
  XCTAssertEqual(composer.cnvSequence("rod"), "ㄖㄡˊ");
  XCTAssertEqual(composer.cnvSequence("rof"), "ㄖㄡˇ");
  XCTAssertEqual(composer.cnvSequence("roj"), "ㄖㄡˋ");
  XCTAssertEqual(composer.cnvSequence("rmd"), "ㄖㄢˊ");
  XCTAssertEqual(composer.cnvSequence("rmf"), "ㄖㄢˇ");
  XCTAssertEqual(composer.cnvSequence("rmj"), "ㄖㄢˋ");
  XCTAssertEqual(composer.cnvSequence("rnd"), "ㄖㄣˊ");
  XCTAssertEqual(composer.cnvSequence("rnf"), "ㄖㄣˇ");
  XCTAssertEqual(composer.cnvSequence("rnj"), "ㄖㄣˋ");
  XCTAssertEqual(composer.cnvSequence("rk"), "ㄖㄤ");
  XCTAssertEqual(composer.cnvSequence("rkd"), "ㄖㄤˊ");
  XCTAssertEqual(composer.cnvSequence("rkf"), "ㄖㄤˇ");
  XCTAssertEqual(composer.cnvSequence("rkj"), "ㄖㄤˋ");
  XCTAssertEqual(composer.cnvSequence("rl"), "ㄖㄥ");
  XCTAssertEqual(composer.cnvSequence("rld"), "ㄖㄥˊ");
  XCTAssertEqual(composer.cnvSequence("rlf"), "ㄖㄥˇ");
  XCTAssertEqual(composer.cnvSequence("rlj"), "ㄖㄥˋ");
  XCTAssertEqual(composer.cnvSequence("rxd"), "ㄖㄨˊ");
  XCTAssertEqual(composer.cnvSequence("rxf"), "ㄖㄨˇ");
  XCTAssertEqual(composer.cnvSequence("rxj"), "ㄖㄨˋ");
  XCTAssertEqual(composer.cnvSequence("rxhd"), "ㄖㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("rxhj"), "ㄖㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("rxad"), "ㄖㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("rxaf"), "ㄖㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("rxaj"), "ㄖㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("rxmd"), "ㄖㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("rxmf"), "ㄖㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("rxmj"), "ㄖㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("rxnd"), "ㄖㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("rxnf"), "ㄖㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("rxnj"), "ㄖㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("rxld"), "ㄖㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("rxlf"), "ㄖㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("rxlj"), "ㄖㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("z"), "ㄗ");
  XCTAssertEqual(composer.cnvSequence("zd"), "ㄗˊ");
  XCTAssertEqual(composer.cnvSequence("zf"), "ㄗˇ");
  XCTAssertEqual(composer.cnvSequence("zj"), "ㄗˋ");
  XCTAssertEqual(composer.cnvSequence("zs"), "ㄗ˙");
  XCTAssertEqual(composer.cnvSequence("zy"), "ㄗㄚ");
  XCTAssertEqual(composer.cnvSequence("zyd"), "ㄗㄚˊ");
  XCTAssertEqual(composer.cnvSequence("zyf"), "ㄗㄚˇ");
  XCTAssertEqual(composer.cnvSequence("zgd"), "ㄗㄜˊ");
  XCTAssertEqual(composer.cnvSequence("zgf"), "ㄗㄜˇ");
  XCTAssertEqual(composer.cnvSequence("zgj"), "ㄗㄜˋ");
  XCTAssertEqual(composer.cnvSequence("zi"), "ㄗㄞ");
  XCTAssertEqual(composer.cnvSequence("zif"), "ㄗㄞˇ");
  XCTAssertEqual(composer.cnvSequence("zij"), "ㄗㄞˋ");
  XCTAssertEqual(composer.cnvSequence("zad"), "ㄗㄟˊ");
  XCTAssertEqual(composer.cnvSequence("zw"), "ㄗㄠ");
  XCTAssertEqual(composer.cnvSequence("zwd"), "ㄗㄠˊ");
  XCTAssertEqual(composer.cnvSequence("zwf"), "ㄗㄠˇ");
  XCTAssertEqual(composer.cnvSequence("zwj"), "ㄗㄠˋ");
  XCTAssertEqual(composer.cnvSequence("zo"), "ㄗㄡ");
  XCTAssertEqual(composer.cnvSequence("zof"), "ㄗㄡˇ");
  XCTAssertEqual(composer.cnvSequence("zoj"), "ㄗㄡˋ");
  XCTAssertEqual(composer.cnvSequence("zm"), "ㄗㄢ");
  XCTAssertEqual(composer.cnvSequence("zmd"), "ㄗㄢˊ");
  XCTAssertEqual(composer.cnvSequence("zmf"), "ㄗㄢˇ");
  XCTAssertEqual(composer.cnvSequence("zmj"), "ㄗㄢˋ");
  XCTAssertEqual(composer.cnvSequence("zn"), "ㄗㄣ");
  XCTAssertEqual(composer.cnvSequence("znf"), "ㄗㄣˇ");
  XCTAssertEqual(composer.cnvSequence("znj"), "ㄗㄣˋ");
  XCTAssertEqual(composer.cnvSequence("zk"), "ㄗㄤ");
  XCTAssertEqual(composer.cnvSequence("zkf"), "ㄗㄤˇ");
  XCTAssertEqual(composer.cnvSequence("zkj"), "ㄗㄤˋ");
  XCTAssertEqual(composer.cnvSequence("zl"), "ㄗㄥ");
  XCTAssertEqual(composer.cnvSequence("zlf"), "ㄗㄥˇ");
  XCTAssertEqual(composer.cnvSequence("zlj"), "ㄗㄥˋ");
  XCTAssertEqual(composer.cnvSequence("zx"), "ㄗㄨ");
  XCTAssertEqual(composer.cnvSequence("zxd"), "ㄗㄨˊ");
  XCTAssertEqual(composer.cnvSequence("zxf"), "ㄗㄨˇ");
  XCTAssertEqual(composer.cnvSequence("zxj"), "ㄗㄨˋ");
  XCTAssertEqual(composer.cnvSequence("zxh"), "ㄗㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("zxhd"), "ㄗㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("zxhf"), "ㄗㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("zxhj"), "ㄗㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("zxhs"), "ㄗㄨㄛ˙");
  XCTAssertEqual(composer.cnvSequence("zxa"), "ㄗㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("zxaf"), "ㄗㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("zxaj"), "ㄗㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("zxm"), "ㄗㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("zxmf"), "ㄗㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("zxmj"), "ㄗㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("zxn"), "ㄗㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("zxnf"), "ㄗㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("zxnj"), "ㄗㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("zxl"), "ㄗㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("zxlf"), "ㄗㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("zxlj"), "ㄗㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("a"), "ㄘ");
  XCTAssertEqual(composer.cnvSequence("ad"), "ㄘˊ");
  XCTAssertEqual(composer.cnvSequence("af"), "ㄘˇ");
  XCTAssertEqual(composer.cnvSequence("aj"), "ㄘˋ");
  XCTAssertEqual(composer.cnvSequence("ay"), "ㄘㄚ");
  XCTAssertEqual(composer.cnvSequence("ayf"), "ㄘㄚˇ");
  XCTAssertEqual(composer.cnvSequence("ayj"), "ㄘㄚˋ");
  XCTAssertEqual(composer.cnvSequence("agj"), "ㄘㄜˋ");
  XCTAssertEqual(composer.cnvSequence("ai"), "ㄘㄞ");
  XCTAssertEqual(composer.cnvSequence("aid"), "ㄘㄞˊ");
  XCTAssertEqual(composer.cnvSequence("aif"), "ㄘㄞˇ");
  XCTAssertEqual(composer.cnvSequence("aij"), "ㄘㄞˋ");
  XCTAssertEqual(composer.cnvSequence("aw"), "ㄘㄠ");
  XCTAssertEqual(composer.cnvSequence("awd"), "ㄘㄠˊ");
  XCTAssertEqual(composer.cnvSequence("awf"), "ㄘㄠˇ");
  XCTAssertEqual(composer.cnvSequence("awj"), "ㄘㄠˋ");
  XCTAssertEqual(composer.cnvSequence("ao"), "ㄘㄡ");
  XCTAssertEqual(composer.cnvSequence("aod"), "ㄘㄡˊ");
  XCTAssertEqual(composer.cnvSequence("aof"), "ㄘㄡˇ");
  XCTAssertEqual(composer.cnvSequence("aoj"), "ㄘㄡˋ");
  XCTAssertEqual(composer.cnvSequence("am"), "ㄘㄢ");
  XCTAssertEqual(composer.cnvSequence("amd"), "ㄘㄢˊ");
  XCTAssertEqual(composer.cnvSequence("amf"), "ㄘㄢˇ");
  XCTAssertEqual(composer.cnvSequence("amj"), "ㄘㄢˋ");
  XCTAssertEqual(composer.cnvSequence("an"), "ㄘㄣ");
  XCTAssertEqual(composer.cnvSequence("and"), "ㄘㄣˊ");
  XCTAssertEqual(composer.cnvSequence("ak"), "ㄘㄤ");
  XCTAssertEqual(composer.cnvSequence("akd"), "ㄘㄤˊ");
  XCTAssertEqual(composer.cnvSequence("akf"), "ㄘㄤˇ");
  XCTAssertEqual(composer.cnvSequence("akj"), "ㄘㄤˋ");
  XCTAssertEqual(composer.cnvSequence("al"), "ㄘㄥ");
  XCTAssertEqual(composer.cnvSequence("ald"), "ㄘㄥˊ");
  XCTAssertEqual(composer.cnvSequence("alf"), "ㄘㄥˇ");
  XCTAssertEqual(composer.cnvSequence("alj"), "ㄘㄥˋ");
  XCTAssertEqual(composer.cnvSequence("ax"), "ㄘㄨ");
  XCTAssertEqual(composer.cnvSequence("axd"), "ㄘㄨˊ");
  XCTAssertEqual(composer.cnvSequence("axf"), "ㄘㄨˇ");
  XCTAssertEqual(composer.cnvSequence("axj"), "ㄘㄨˋ");
  XCTAssertEqual(composer.cnvSequence("axh"), "ㄘㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("axhd"), "ㄘㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("axhf"), "ㄘㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("axhj"), "ㄘㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("axa"), "ㄘㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("axaf"), "ㄘㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("axaj"), "ㄘㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("axm"), "ㄘㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("axmd"), "ㄘㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("axmf"), "ㄘㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("axmj"), "ㄘㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("axn"), "ㄘㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("axnd"), "ㄘㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("axnf"), "ㄘㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("axnj"), "ㄘㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("axl"), "ㄘㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("axld"), "ㄘㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("axlf"), "ㄘㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("axlj"), "ㄘㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("s"), "ㄙ");
  XCTAssertEqual(composer.cnvSequence("sf"), "ㄙˇ");
  XCTAssertEqual(composer.cnvSequence("sj"), "ㄙˋ");
  XCTAssertEqual(composer.cnvSequence("sy"), "ㄙㄚ");
  XCTAssertEqual(composer.cnvSequence("syf"), "ㄙㄚˇ");
  XCTAssertEqual(composer.cnvSequence("syj"), "ㄙㄚˋ");
  XCTAssertEqual(composer.cnvSequence("sys"), "ㄙㄚ˙");
  XCTAssertEqual(composer.cnvSequence("sg"), "ㄙㄜ");
  XCTAssertEqual(composer.cnvSequence("sgj"), "ㄙㄜˋ");
  XCTAssertEqual(composer.cnvSequence("si"), "ㄙㄞ");
  XCTAssertEqual(composer.cnvSequence("sid"), "ㄙㄞˊ");
  XCTAssertEqual(composer.cnvSequence("sif"), "ㄙㄞˇ");
  XCTAssertEqual(composer.cnvSequence("sij"), "ㄙㄞˋ");
  XCTAssertEqual(composer.cnvSequence("sa"), "ㄙㄟ");
  XCTAssertEqual(composer.cnvSequence("sw"), "ㄙㄠ");
  XCTAssertEqual(composer.cnvSequence("swf"), "ㄙㄠˇ");
  XCTAssertEqual(composer.cnvSequence("swj"), "ㄙㄠˋ");
  XCTAssertEqual(composer.cnvSequence("so"), "ㄙㄡ");
  XCTAssertEqual(composer.cnvSequence("sof"), "ㄙㄡˇ");
  XCTAssertEqual(composer.cnvSequence("soj"), "ㄙㄡˋ");
  XCTAssertEqual(composer.cnvSequence("sm"), "ㄙㄢ");
  XCTAssertEqual(composer.cnvSequence("smf"), "ㄙㄢˇ");
  XCTAssertEqual(composer.cnvSequence("smj"), "ㄙㄢˋ");
  XCTAssertEqual(composer.cnvSequence("sn"), "ㄙㄣ");
  XCTAssertEqual(composer.cnvSequence("snf"), "ㄙㄣˇ");
  XCTAssertEqual(composer.cnvSequence("sk"), "ㄙㄤ");
  XCTAssertEqual(composer.cnvSequence("skf"), "ㄙㄤˇ");
  XCTAssertEqual(composer.cnvSequence("skj"), "ㄙㄤˋ");
  XCTAssertEqual(composer.cnvSequence("sl"), "ㄙㄥ");
  XCTAssertEqual(composer.cnvSequence("slj"), "ㄙㄥˋ");
  XCTAssertEqual(composer.cnvSequence("sx"), "ㄙㄨ");
  XCTAssertEqual(composer.cnvSequence("sxd"), "ㄙㄨˊ");
  XCTAssertEqual(composer.cnvSequence("sxf"), "ㄙㄨˇ");
  XCTAssertEqual(composer.cnvSequence("sxj"), "ㄙㄨˋ");
  XCTAssertEqual(composer.cnvSequence("sxh"), "ㄙㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("sxhd"), "ㄙㄨㄛˊ");
  XCTAssertEqual(composer.cnvSequence("sxhf"), "ㄙㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("sxhj"), "ㄙㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("sxa"), "ㄙㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("sxad"), "ㄙㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("sxaf"), "ㄙㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("sxaj"), "ㄙㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("sxm"), "ㄙㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("sxmf"), "ㄙㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("sxmj"), "ㄙㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("sxn"), "ㄙㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("sxnf"), "ㄙㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("sxnj"), "ㄙㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("sxl"), "ㄙㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("sxld"), "ㄙㄨㄥˊ");
  XCTAssertEqual(composer.cnvSequence("sxlf"), "ㄙㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("sxlj"), "ㄙㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("y"), "ㄚ");
  XCTAssertEqual(composer.cnvSequence("yd"), "ㄚˊ");
  XCTAssertEqual(composer.cnvSequence("yj"), "ㄚˋ");
  XCTAssertEqual(composer.cnvSequence("ys"), "ㄚ˙");
  XCTAssertEqual(composer.cnvSequence("h"), "ㄛ");
  XCTAssertEqual(composer.cnvSequence("hd"), "ㄛˊ");
  XCTAssertEqual(composer.cnvSequence("hf"), "ㄛˇ");
  XCTAssertEqual(composer.cnvSequence("hj"), "ㄛˋ");
  XCTAssertEqual(composer.cnvSequence("g"), "ㄜ");
  XCTAssertEqual(composer.cnvSequence("gd"), "ㄜˊ");
  XCTAssertEqual(composer.cnvSequence("gf"), "ㄜˇ");
  XCTAssertEqual(composer.cnvSequence("gj"), "ㄜˋ");
  // XCTAssertEqual(composer.cnvSequence("ed"), "ㄝˊ");
  // XCTAssertEqual(composer.cnvSequence("ef"), "ㄝˇ");
  // XCTAssertEqual(composer.cnvSequence("ej"), "ㄝˋ");
  // XCTAssertEqual(composer.cnvSequence("es"), "ㄝ˙");
  XCTAssertEqual(composer.cnvSequence("i"), "ㄞ");
  XCTAssertEqual(composer.cnvSequence("id"), "ㄞˊ");
  XCTAssertEqual(composer.cnvSequence("if"), "ㄞˇ");
  XCTAssertEqual(composer.cnvSequence("ij"), "ㄞˋ");
  // XCTAssertEqual(composer.cnvSequence("aj"), "ㄟˋ");
  XCTAssertEqual(composer.cnvSequence("w"), "ㄠ");
  XCTAssertEqual(composer.cnvSequence("wd"), "ㄠˊ");
  XCTAssertEqual(composer.cnvSequence("wf"), "ㄠˇ");
  XCTAssertEqual(composer.cnvSequence("wj"), "ㄠˋ");
  XCTAssertEqual(composer.cnvSequence("o"), "ㄡ");
  XCTAssertEqual(composer.cnvSequence("od"), "ㄡˊ");
  XCTAssertEqual(composer.cnvSequence("of"), "ㄡˇ");
  XCTAssertEqual(composer.cnvSequence("oj"), "ㄡˋ");
  XCTAssertEqual(composer.cnvSequence("os"), "ㄡ˙");
  XCTAssertEqual(composer.cnvSequence("m"), "ㄢ");
  XCTAssertEqual(composer.cnvSequence("md"), "ㄢˊ");
  XCTAssertEqual(composer.cnvSequence("mf"), "ㄢˇ");
  XCTAssertEqual(composer.cnvSequence("mj"), "ㄢˋ");
  XCTAssertEqual(composer.cnvSequence("n"), "ㄣ");
  XCTAssertEqual(composer.cnvSequence("nd"), "ㄣˊ");
  XCTAssertEqual(composer.cnvSequence("nf"), "ㄣˇ");
  XCTAssertEqual(composer.cnvSequence("nj"), "ㄣˋ");
  XCTAssertEqual(composer.cnvSequence("ns"), "ㄣ˙");
  XCTAssertEqual(composer.cnvSequence("k"), "ㄤ");
  XCTAssertEqual(composer.cnvSequence("kd"), "ㄤˊ");
  XCTAssertEqual(composer.cnvSequence("kf"), "ㄤˇ");
  XCTAssertEqual(composer.cnvSequence("kj"), "ㄤˋ");
  // XCTAssertEqual(composer.cnvSequence("l"), "ㄥ");
  // XCTAssertEqual(composer.cnvSequence("lj"), "ㄥˋ");
  XCTAssertEqual(composer.cnvSequence("l"), "ㄦ");
  XCTAssertEqual(composer.cnvSequence("ld"), "ㄦˊ");
  XCTAssertEqual(composer.cnvSequence("lf"), "ㄦˇ");
  XCTAssertEqual(composer.cnvSequence("lj"), "ㄦˋ");
  XCTAssertEqual(composer.cnvSequence("ls"), "ㄦ˙");
  XCTAssertEqual(composer.cnvSequence("e"), "ㄧ");
  XCTAssertEqual(composer.cnvSequence("ed"), "ㄧˊ");
  XCTAssertEqual(composer.cnvSequence("ef"), "ㄧˇ");
  XCTAssertEqual(composer.cnvSequence("ej"), "ㄧˋ");
  XCTAssertEqual(composer.cnvSequence("ey"), "ㄧㄚ");
  XCTAssertEqual(composer.cnvSequence("eyd"), "ㄧㄚˊ");
  XCTAssertEqual(composer.cnvSequence("eyf"), "ㄧㄚˇ");
  XCTAssertEqual(composer.cnvSequence("eyj"), "ㄧㄚˋ");
  XCTAssertEqual(composer.cnvSequence("eys"), "ㄧㄚ˙");
  XCTAssertEqual(composer.cnvSequence("eh"), "ㄧㄛ");
  XCTAssertEqual(composer.cnvSequence("ehs"), "ㄧㄛ˙");
  XCTAssertEqual(composer.cnvSequence("ee"), "ㄧㄝ");
  XCTAssertEqual(composer.cnvSequence("eed"), "ㄧㄝˊ");
  XCTAssertEqual(composer.cnvSequence("eef"), "ㄧㄝˇ");
  XCTAssertEqual(composer.cnvSequence("eej"), "ㄧㄝˋ");
  XCTAssertEqual(composer.cnvSequence("ees"), "ㄧㄝ˙");
  XCTAssertEqual(composer.cnvSequence("eid"), "ㄧㄞˊ");
  XCTAssertEqual(composer.cnvSequence("ew"), "ㄧㄠ");
  XCTAssertEqual(composer.cnvSequence("ewd"), "ㄧㄠˊ");
  XCTAssertEqual(composer.cnvSequence("ewf"), "ㄧㄠˇ");
  XCTAssertEqual(composer.cnvSequence("ewj"), "ㄧㄠˋ");
  XCTAssertEqual(composer.cnvSequence("eo"), "ㄧㄡ");
  XCTAssertEqual(composer.cnvSequence("eod"), "ㄧㄡˊ");
  XCTAssertEqual(composer.cnvSequence("eof"), "ㄧㄡˇ");
  XCTAssertEqual(composer.cnvSequence("eoj"), "ㄧㄡˋ");
  XCTAssertEqual(composer.cnvSequence("em"), "ㄧㄢ");
  XCTAssertEqual(composer.cnvSequence("emd"), "ㄧㄢˊ");
  XCTAssertEqual(composer.cnvSequence("emf"), "ㄧㄢˇ");
  XCTAssertEqual(composer.cnvSequence("emj"), "ㄧㄢˋ");
  XCTAssertEqual(composer.cnvSequence("en"), "ㄧㄣ");
  XCTAssertEqual(composer.cnvSequence("end"), "ㄧㄣˊ");
  XCTAssertEqual(composer.cnvSequence("enf"), "ㄧㄣˇ");
  XCTAssertEqual(composer.cnvSequence("enj"), "ㄧㄣˋ");
  XCTAssertEqual(composer.cnvSequence("ek"), "ㄧㄤ");
  XCTAssertEqual(composer.cnvSequence("ekd"), "ㄧㄤˊ");
  XCTAssertEqual(composer.cnvSequence("ekf"), "ㄧㄤˇ");
  XCTAssertEqual(composer.cnvSequence("ekj"), "ㄧㄤˋ");
  XCTAssertEqual(composer.cnvSequence("el"), "ㄧㄥ");
  XCTAssertEqual(composer.cnvSequence("eld"), "ㄧㄥˊ");
  XCTAssertEqual(composer.cnvSequence("elf"), "ㄧㄥˇ");
  XCTAssertEqual(composer.cnvSequence("elj"), "ㄧㄥˋ");
  XCTAssertEqual(composer.cnvSequence("x"), "ㄨ");
  XCTAssertEqual(composer.cnvSequence("xd"), "ㄨˊ");
  XCTAssertEqual(composer.cnvSequence("xf"), "ㄨˇ");
  XCTAssertEqual(composer.cnvSequence("xj"), "ㄨˋ");
  XCTAssertEqual(composer.cnvSequence("xy"), "ㄨㄚ");
  XCTAssertEqual(composer.cnvSequence("xyd"), "ㄨㄚˊ");
  XCTAssertEqual(composer.cnvSequence("xyf"), "ㄨㄚˇ");
  XCTAssertEqual(composer.cnvSequence("xyj"), "ㄨㄚˋ");
  XCTAssertEqual(composer.cnvSequence("xys"), "ㄨㄚ˙");
  XCTAssertEqual(composer.cnvSequence("xh"), "ㄨㄛ");
  XCTAssertEqual(composer.cnvSequence("xhf"), "ㄨㄛˇ");
  XCTAssertEqual(composer.cnvSequence("xhj"), "ㄨㄛˋ");
  XCTAssertEqual(composer.cnvSequence("xi"), "ㄨㄞ");
  XCTAssertEqual(composer.cnvSequence("xif"), "ㄨㄞˇ");
  XCTAssertEqual(composer.cnvSequence("xij"), "ㄨㄞˋ");
  XCTAssertEqual(composer.cnvSequence("xa"), "ㄨㄟ");
  XCTAssertEqual(composer.cnvSequence("xad"), "ㄨㄟˊ");
  XCTAssertEqual(composer.cnvSequence("xaf"), "ㄨㄟˇ");
  XCTAssertEqual(composer.cnvSequence("xaj"), "ㄨㄟˋ");
  XCTAssertEqual(composer.cnvSequence("xm"), "ㄨㄢ");
  XCTAssertEqual(composer.cnvSequence("xmd"), "ㄨㄢˊ");
  XCTAssertEqual(composer.cnvSequence("xmf"), "ㄨㄢˇ");
  XCTAssertEqual(composer.cnvSequence("xmj"), "ㄨㄢˋ");
  XCTAssertEqual(composer.cnvSequence("xn"), "ㄨㄣ");
  XCTAssertEqual(composer.cnvSequence("xnd"), "ㄨㄣˊ");
  XCTAssertEqual(composer.cnvSequence("xnf"), "ㄨㄣˇ");
  XCTAssertEqual(composer.cnvSequence("xnj"), "ㄨㄣˋ");
  XCTAssertEqual(composer.cnvSequence("xk"), "ㄨㄤ");
  XCTAssertEqual(composer.cnvSequence("xkd"), "ㄨㄤˊ");
  XCTAssertEqual(composer.cnvSequence("xkf"), "ㄨㄤˇ");
  XCTAssertEqual(composer.cnvSequence("xkj"), "ㄨㄤˋ");
  XCTAssertEqual(composer.cnvSequence("xl"), "ㄨㄥ");
  XCTAssertEqual(composer.cnvSequence("xlf"), "ㄨㄥˇ");
  XCTAssertEqual(composer.cnvSequence("xlj"), "ㄨㄥˋ");
  XCTAssertEqual(composer.cnvSequence("u"), "ㄩ");
  XCTAssertEqual(composer.cnvSequence("ud"), "ㄩˊ");
  XCTAssertEqual(composer.cnvSequence("uf"), "ㄩˇ");
  XCTAssertEqual(composer.cnvSequence("uj"), "ㄩˋ");
  XCTAssertEqual(composer.cnvSequence("ue"), "ㄩㄝ");
  XCTAssertEqual(composer.cnvSequence("uef"), "ㄩㄝˇ");
  XCTAssertEqual(composer.cnvSequence("uej"), "ㄩㄝˋ");
  XCTAssertEqual(composer.cnvSequence("um"), "ㄩㄢ");
  XCTAssertEqual(composer.cnvSequence("umd"), "ㄩㄢˊ");
  XCTAssertEqual(composer.cnvSequence("umf"), "ㄩㄢˇ");
  XCTAssertEqual(composer.cnvSequence("umj"), "ㄩㄢˋ");
  XCTAssertEqual(composer.cnvSequence("un"), "ㄩㄣ");
  XCTAssertEqual(composer.cnvSequence("und"), "ㄩㄣˊ");
  XCTAssertEqual(composer.cnvSequence("unf"), "ㄩㄣˇ");
  XCTAssertEqual(composer.cnvSequence("unj"), "ㄩㄣˋ");
  XCTAssertEqual(composer.cnvSequence("ul"), "ㄩㄥ");
  XCTAssertEqual(composer.cnvSequence("uld"), "ㄩㄥˊ");
  XCTAssertEqual(composer.cnvSequence("ulf"), "ㄩㄥˇ");
  XCTAssertEqual(composer.cnvSequence("ulj"), "ㄩㄥˋ");
}

@end