diff options
Diffstat (limited to 'input-methods/m17n/swanalekha/te-swanalekha.mim')
| -rwxr-xr-x | input-methods/m17n/swanalekha/te-swanalekha.mim | 1335 |
1 files changed, 1335 insertions, 0 deletions
diff --git a/input-methods/m17n/swanalekha/te-swanalekha.mim b/input-methods/m17n/swanalekha/te-swanalekha.mim new file mode 100755 index 0000000..82c26f8 --- /dev/null +++ b/input-methods/m17n/swanalekha/te-swanalekha.mim @@ -0,0 +1,1335 @@ +(input-method te swanalekha) + +(description "Swanalekha Telugu input method") + + +(title "telugu") +(variable + (candidates-group-size)) + +(map + (starter + ("~") ("@") ("^") + ("0") ("1") ("2") ("3") ("4") ("~") + ("5") ("6") ("7") ("8") ("9") ("_") + ("A") ("C") ("D") ("G") ("H") ("I") ("J") ("K") ("L") + ("M") ("N") ("O") ("Q") ("R") ("S") ("T") ("U") ("Y") + ("B") ("J") ("P") ("E") ("V") ("W") ("X") + ("a") ("b") ("c") ("d") ("e") ("f") ("g") ("h") ("i") + ("j") ("k") ("l") ("m") ("n") ("o") ("p") ("q") ("r") + ("s") ("t") ("u") ("v") ("w") ("x") ("y") ("z")) + + (map + + ("a" (("అ") ("ఆ") ("ఏ"))) + ("A" (("ఆ") ("ఏ"))) + ("@aa" (("ా"))) + ("aa" (("ఆ"))) + ("ae" (("ఎ"))) + ("@ah" (("ః"))) + ("@aH" (("ః"))) + ("aH" (("అః"))) + ("ai" (("ఐ"))) + ("aM" (("అఁ"))) + ("au" (("ఔ"))) + ("b^" (("బ్"))) + ("b" (("బ్") ("బ్బ్") ("బి"))) + ("B^" (("భ్"))) + ("B" (("భ్") ("బ్") ("బి"))) + ("ba" (("బ"))) + ("bA" (("బా"))) + ("Ba" (("భ") ("బ") ("బా"))) + ("BA" (("భా") ("బి.ఏ."))) + ("baa" (("బా"))) + ("Baa" (("భా") ("బా"))) + ("bae" (("బై"))) + ("baH" (("బః"))) + ("BaH" (("భః"))) + ("bai" (("బై") ("బాయ్"))) + ("Bai" (("భై"))) + ("baM" (("బఁ"))) + ("BaM" (("భఁ"))) + ("bau" (("బౌ") ("బౌ") ("భౌ"))) + ("Bau" (("భౌ") ("భే"))) + ("be" (("బే"))) + ("bE" (("బై"))) + ("Be" (("భే"))) + ("BE" (("భై"))) + ("bee" (("బీ"))) + ("Bee" (("భీ"))) + ("bei" (("బై"))) + ("Bei" (("భై"))) + ("bh^" (("భ్"))) + ("bh" (("భ్"))) + ("bha" (("భ"))) + ("bhA" (("భా"))) + ("bhaa" (("భా"))) + ("bhae" (("భై"))) + ("bhaH" (("భః"))) + ("bhai" (("భై") ("భాయ్"))) + ("bhaM" (("భఁ"))) + ("bhau" (("భౌ") ("భే"))) + ("bhe" (("భే"))) + ("bhE" (("భై"))) + ("bhee" (("భీ"))) + ("bhei" (("భై"))) + ("bhi" (("భి"))) + ("bhI" (("భి"))) + ("bhii" (("భీ"))) + ("bho" (("భో"))) + ("bhO" (("భౌ"))) + ("bhoo" (("భూ"))) + ("bhou" (("భే"))) + ("bhR" (("భృ"))) + ("bhu" (("భు"))) + ("bhU" (("భూ"))) + ("bhuu" (("భూ"))) + ("bi" (("బి") ("బై"))) + ("bI" (("బీ"))) + ("Bi" (("భి") ("బై"))) + ("BI" (("భీ"))) + ("bii" (("బీ"))) + ("Bii" (("భీ"))) + ("bo" (("బో"))) + ("bO" (("బౌ"))) + ("Bo" (("భో") ("బౌ"))) + ("BO" (("భౌ"))) + ("boo" (("బూ") ("బౌ"))) + ("Boo" (("భూ"))) + ("bou" (("బౌ"))) + ("Bou" (("భే"))) + ("bR" (("బృ"))) + ("BR" (("భృ"))) + ("bu" (("బు"))) + ("bU" (("బూ"))) + ("Bu" (("భు") ("బు"))) + ("BU" (("భూ"))) + ("buu" (("బూ"))) + ("Buu" (("భూ"))) + ("c" (("క్") ("సి"))) + ("C" (("సి"))) + ("ca" (("క") ("కా") ("కై"))) + ("cA" (("కా"))) + ("caa" (("కా"))) + ("cae" (("కై"))) + ("cai" (("కై"))) + ("cau" (("కౌ"))) + ("ce" (("కే") ("స్"))) + ("cE" (("కై"))) + ("cee" (("కి"))) + ("cei" (("కై"))) + ("ch^" (("చ్"))) + ("ch" (("చ్") ("చ్చ్") ("క్క్"))) + ("Ch^" (("ఛ్"))) + ("Ch" (("ఛ్"))) + ("cha" (("చ") ("చ్చ") ("చ్ఛ"))) + ("chA" (("చా"))) + ("Cha" (("ఛ") ("చ") ("చ్చ"))) + ("ChA" (("ఛా"))) + ("chaa" (("చా"))) + ("Chaa" (("ఛా"))) + ("chae" (("చై"))) + ("Chae" (("ఛై"))) + ("chaH" (("చః"))) + ("ChaH" (("ఛః"))) + ("chai" (("చై") ("చాయ్"))) + ("Chai" (("ఛై"))) + ("chaM" (("చఁ"))) + ("ChaM" (("ఛఁ"))) + ("chau" (("చౌ"))) + ("Chau" (("ఛౌ") ("ఛే"))) + ("che" (("చే") ("చ్చే"))) + ("chE" (("చై"))) + ("Che" (("ఛే"))) + ("ChE" (("ఛై"))) + ("chee" (("చీ") ("చ్చీ"))) + ("Chee" (("ఛీ"))) + ("chei" (("చై"))) + ("Chei" (("ఛై"))) + ("chh^" (("ఛ్"))) + ("chh" (("ఛ్"))) + ("chha" (("ఛ") ("చ్చ"))) + ("chhA" (("ఛా"))) + ("chhaa" (("ఛా"))) + ("chhae" (("ఛై"))) + ("chhaH" (("ఛః"))) + ("chhai" (("ఛై"))) + ("chhaM" (("ఛఁ"))) + ("chhau" (("ఛౌ") ("ఛే"))) + ("chhe" (("ఛే"))) + ("chhE" (("ఛై"))) + ("chhee" (("ఛీ"))) + ("chhei" (("ఛై"))) + ("chhi" (("ఛీ"))) + ("chhI" (("ఛి"))) + ("chhii" (("ఛీ"))) + ("chho" (("ఛో"))) + ("chhO" (("ఛౌ"))) + ("chhoo" (("ఛూ"))) + ("chhou" (("ఛే"))) + ("chhR" (("ఛృ"))) + ("chhu" (("ఛు"))) + ("chhU" (("ఛూ"))) + ("chhuu" (("ఛూ"))) + ("chi" (("చి") ("చ్చి") ("చై"))) + ("chI" (("చీ"))) + ("Chi" (("ఛి") ("చి"))) + ("ChI" (("ఛీ"))) + ("chii" (("చీ"))) + ("Chii" (("ఛీ"))) + ("cho" (("చో") ("చౌ"))) + ("chO" (("చౌ"))) + ("Cho" (("ఛో"))) + ("ChO" (("ఛౌ"))) + ("choo" (("చూ") ("చ్చూ") ("చౌ"))) + ("Choo" (("ఛూ"))) + ("chou" (("చే"))) + ("Chou" (("ఛే"))) + ("chR" (("చృ"))) + ("ChR" (("ఛృ"))) + ("chu" (("చు") ("చ్యు"))) + ("chU" (("చూ"))) + ("Chu" (("ఛు") ("చు"))) + ("ChU" (("ఛూ"))) + ("chuu" (("చూ") ("చ్చూ"))) + ("Chuu" (("ఛూ"))) + ("ci" (("కి") ("సి") ("సై"))) + ("cI" (("కీ"))) + ("ck" (("క్క్"))) + ("cka" (("క"))) + ("co" (("కో"))) + ("cO" (("కో"))) + ("coo" (("కూ"))) + ("cou" (("కే"))) + ("cR" (("కృ"))) + ("cu" (("కు"))) + ("cU" (("కూ"))) + ("cuu" (("కూ"))) + ("d^" (("ద్"))) + ("d" (("ద్") ("ట్") ("డి") ("ద్ద్"))) + ("D^" (("డ్"))) + ("D" (("డ్") ("ద్") ("డి"))) + ("da" (("ద") ("ట") ("డ"))) + ("dA" (("దా") ("టా"))) + ("Da" (("డ") ("ద") ("ఠ"))) + ("DA" (("డా"))) + ("daa" (("దా") ("టా"))) + ("Daa" (("డా"))) + ("dae" (("దై"))) + ("Dae" (("డై"))) + ("daH" (("దః"))) + ("DaH" (("డః"))) + ("dai" (("దై") ("డాయ్"))) + ("Dai" (("డై"))) + ("daM" (("దఁ"))) + ("DaM" (("డఁ"))) + ("dau" (("దౌ") ("దే"))) + ("Dau" (("డౌ") ("డే"))) + ("de" (("దే") ("టే") ("తే"))) + ("dE" (("దై") ("తై"))) + ("De" (("డే") ("టే"))) + ("DE" (("డై"))) + ("dee" (("దీ") ("టీ"))) + ("Dee" (("డీ"))) + ("dei" (("దై") ("డైయ్"))) + ("Dei" (("డై"))) + ("dh^" (("ధ్"))) + ("dh" (("ధ్"))) + ("Dh^" (("ఢ్"))) + ("Dh" (("ఢ్"))) + ("dha" (("ధ"))) + ("dhA" (("ధా"))) + ("Dha" (("ఢ"))) + ("DhA" (("ఢా"))) + ("dhaa" (("ధా"))) + ("Dhaa" (("ఢా"))) + ("dhae" (("ధై"))) + ("Dhae" (("ఢై"))) + ("dhaH" (("ధః"))) + ("DhaH" (("ఢః"))) + ("dhai" (("ధై"))) + ("Dhai" (("ఢై"))) + ("dhaM" (("ధఁ"))) + ("DhaM" (("ఢఁ"))) + ("dhau" (("ధౌ") ("ధే"))) + ("Dhau" (("ఢౌ") ("ఢే"))) + ("dhe" (("ధే"))) + ("dhE" (("ధై"))) + ("Dhe" (("ఢే"))) + ("DhE" (("ఢై"))) + ("dhee" (("ధి"))) + ("Dhee" (("ఢీ"))) + ("dhei" (("ధై"))) + ("Dhei" (("ఢై"))) + ("dhi" (("ధి"))) + ("dhI" (("ధి"))) + ("Dhi" (("ఢి"))) + ("DhI" (("ఢీ"))) + ("dhii" (("ధి"))) + ("Dhii" (("ఢీ"))) + ("dho" (("ధో"))) + ("dhO" (("ధౌ"))) + ("Dho" (("ఢో"))) + ("DhO" (("ఢౌ"))) + ("dhoo" (("ధూ"))) + ("Dhoo" (("ఢూ"))) + ("dhou" (("ధే"))) + ("Dhou" (("ఢే"))) + ("dhR" (("ధృ"))) + ("DhR" (("ఢృ"))) + ("dhu" (("ధు"))) + ("dhU" (("ధూ"))) + ("Dhu" (("ఢు"))) + ("DhU" (("ఢూ"))) + ("dhuu" (("ధూ"))) + ("Dhuu" (("ఢూ"))) + ("di" (("ది") ("టి") ("ధి") ("థి") ("డై"))) + ("dI" (("ది") ("టి"))) + ("Di" (("డి"))) + ("DI" (("డీ"))) + ("dii" (("దీ") ("టీ"))) + ("Dii" (("డీ"))) + ("do" (("దో"))) + ("dO" (("దౌ"))) + ("Do" (("డో"))) + ("DO" (("డౌ"))) + ("doo" (("దూ"))) + ("Doo" (("డూ"))) + ("dou" (("దే"))) + ("Dou" (("డే"))) + ("dR" (("దృ"))) + ("DR" (("డృ"))) + ("du" (("దు") ("టు") ("దుః"))) + ("dU" (("దూ"))) + ("Du" (("డు") ("దు"))) + ("DU" (("డూ"))) + ("duu" (("దూ"))) + ("Duu" (("డూ"))) + ("e" (("ఏ") ("ఇ"))) + ("E" (("ఎ") ("ఇ"))) + ("ee" (("ఈ"))) + ("ei" (("ఐ"))) + ("f^" (("ఫ్"))) + ("f" (("ఫ్") ("ఏఫ్"))) + ("fa" (("ఫ"))) + ("fA" (("ఫా"))) + ("faa" (("ఫా"))) + ("faH" (("ఫః"))) + ("fai" (("ఫై"))) + ("faM" (("ఫఁ"))) + ("fau" (("ఫౌ") ("ఫే"))) + ("fe" (("ఫే"))) + ("fE" (("ఫై"))) + ("fee" (("ఫీ"))) + ("fei" (("ఫై"))) + ("fi" (("ఫి"))) + ("fI" (("ఫీ"))) + ("fii" (("ఫీ"))) + ("fo" (("ఫో"))) + ("fO" (("ఫౌ"))) + ("foo" (("ఫూ"))) + ("fou" (("ఫే"))) + ("fR" (("ఫృ"))) + ("fu" (("ఫు"))) + ("fU" (("ఫూ"))) + ("fuu" (("ఫూ"))) + ("g^" (("గ్"))) + ("g" (("గ్") ("జి"))) + ("G^" (("ఘ్"))) + ("G" (("ఘ్") ("జి") ("గ్గి"))) + ("ga" (("గ") ("జ") ("క") ("ఖ"))) + ("gA" (("గా"))) + ("Ga" (("ఘ") ("గ") ("గ్గ") ("జ"))) + ("GA" (("ఘా") ("గ్గా"))) + ("gaa" (("గా"))) + ("Gaa" (("ఘా") ("గ్గా"))) + ("gae" (("గై"))) + ("Gae" (("ఘై") ("గ్గై"))) + ("gaH" (("గః"))) + ("GaH" (("ఘః"))) + ("gai" (("గై"))) + ("Gai" (("ఘై") ("గయ్") ("గేయ్") ("గ్గై"))) + ("gaM" (("గఁ"))) + ("GaM" (("ఘఁ"))) + ("gau" (("గౌ") ("గే"))) + ("Gau" (("ఘౌ") ("గౌ") ("ఘే"))) + ("ge" (("గే"))) + ("gE" (("గై"))) + ("Ge" (("ఘే") ("గే") ("గ్గే") ("జే"))) + ("GE" (("ఘై") ("గ్గై"))) + ("gee" (("గీ"))) + ("Gee" (("ఘి") ("గ్గి"))) + ("gei" (("గై"))) + ("Gei" (("ఘై") ("గ్గై"))) + ("gh^" (("ఘ్"))) + ("gh" (("ఘ్"))) + ("gha" (("ఘ") ("ఖ"))) + ("ghA" (("ఘా"))) + ("ghaa" (("ఘా"))) + ("ghae" (("ఘై"))) + ("ghaH" (("ఘః"))) + ("ghai" (("ఘై"))) + ("ghaM" (("ఘఁ"))) + ("ghau" (("ఘౌ"))) + ("ghe" (("ఘే"))) + ("ghE" (("ఘై"))) + ("ghee" (("ఘి"))) + ("ghei" (("ఘై"))) + ("ghi" (("ఘి"))) + ("ghI" (("ఘి"))) + ("ghii" (("ఘి"))) + ("gho" (("ఘో"))) + ("ghO" (("ఘౌ"))) + ("ghoo" (("ఘూ"))) + ("ghou" (("ఘే"))) + ("ghR" (("ఘృ"))) + ("ghu" (("ఘు"))) + ("ghU" (("ఘూ"))) + ("ghuu" (("ఘూ"))) + ("gi" (("గి") ("కి") ("జి"))) + ("gI" (("గీ"))) + ("Gi" (("ఘి") ("గ్గీ"))) + ("GI" (("ఘి") ("గ్గి") ("గ్గి"))) + ("gii" (("గీ"))) + ("Gii" (("ఘీ") ("గ్గీ"))) + ("go" (("గో") ("గౌ"))) + ("gO" (("గౌ"))) + ("Go" (("ఘో") ("గౌ") ("గో") ("గ్గో"))) + ("GO" (("ఘౌ"))) + ("goo" (("గూ") ("గౌ"))) + ("Goo" (("ఘూ") ("గ్గూ") ("ఘౌ") ("గ్గౌ"))) + ("gou" (("గే"))) + ("Gou" (("ఘే"))) + ("gR" (("గృ"))) + ("GR" (("ఘృ") ("గ్గృ"))) + ("gu" (("గు"))) + ("gU" (("గూ"))) + ("Gu" (("ఘు") ("గు") ("గ్గు"))) + ("GU" (("ఘూ") ("గ్గూ"))) + ("guu" (("గూ"))) + ("Guu" (("ఘూ") ("గ్గూ"))) + ("h^" (("హ్"))) + ("h" (("హ్") ("ఏచ్") ("ఏచ్చ్"))) + ("H" (("ఏచ్చ్"))) + ("ha" (("హ") ("హా"))) + ("hA" (("హా"))) + ("haa" (("హా"))) + ("haH" (("హః"))) + ("hai" (("హై") ("హాయ్"))) + ("haM" (("హఁ"))) + ("hau" (("హౌ"))) + ("he" (("హే") ("హి"))) + ("hE" (("హై"))) + ("hee" (("హీ"))) + ("hei" (("హై") ("హైయ్"))) + ("hi" (("హి") ("హాయ్"))) + ("hI" (("హీ"))) + ("hii" (("హీ"))) + ("ho" (("హో") ("హౌ"))) + ("hO" (("హౌ"))) + ("hoo" (("హూ"))) + ("hou" (("హౌ"))) + ("hR" (("హృ"))) + ("hu" (("హు"))) + ("hU" (("హూ"))) + ("huu" (("హూ"))) + ("I" (("ఈ") ("ఐ"))) + ("@ii" (("ీ"))) + ("ii" (("ఈ"))) + ("j^" (("జ్"))) + ("j" (("జ్") ("జే"))) + ("J" (("ఝ్") ("జే"))) + ("ja" (("జ") ("జే"))) + ("jA" (("జా"))) + ("Ja" (("ఝ") ("జ") ("జే"))) + ("JA" (("ఝా"))) + ("jaa" (("జా"))) + ("Jaa" (("ఝా"))) + ("jae" (("జై"))) + ("Jae" (("ఝై"))) + ("jaH" (("జః"))) + ("JaH" (("ఝః"))) + ("jai" (("జై") ("జయ్"))) + ("Jai" (("ఝై") ("జయ్"))) + ("jaM" (("జఁ"))) + ("JaM" (("ఝఁ"))) + ("jau" (("జౌ") ("జే"))) + ("Jau" (("ఝౌ") ("ఝే"))) + ("je" (("జే") ("జి"))) + ("jE" (("జై"))) + ("Je" (("ఝే"))) + ("JE" (("ఝై"))) + ("jee" (("జీ"))) + ("Jee" (("ఝీ") ("జీ"))) + ("jei" (("జై"))) + ("Jei" (("ఝై"))) + ("jh^" (("ఝ్"))) + ("jh" (("ఝ్"))) + ("jha" (("ఝ"))) + ("jhA" (("ఝా"))) + ("jhaa" (("ఝా"))) + ("jhae" (("ఝై"))) + ("jhaH" (("ఝః"))) + ("jhai" (("ఝై"))) + ("jhaM" (("ఝఁ"))) + ("jhau" (("ఝౌ") ("ఝే"))) + ("jhe" (("ఝే"))) + ("jhE" (("ఝై"))) + ("jhee" (("ఝి"))) + ("jhei" (("ఝై"))) + ("jhi" (("ఝి"))) + ("jhI" (("ఝి"))) + ("jhii" (("ఝి"))) + ("jho" (("ఝో"))) + ("jhO" (("ఝౌ"))) + ("jhoo" (("ఝూ") ("ఝౌ"))) + ("jhou" (("ఝే"))) + ("jhR" (("ఝృ"))) + ("jhu" (("ఝు"))) + ("jhU" (("ఝూ"))) + ("jhuu" (("ఝూ"))) + ("ji" (("జి") ("జై"))) + ("jI" (("జి"))) + ("Ji" (("ఝి") ("జి") ("జై"))) + ("JI" (("ఝీ"))) + ("jii" (("జీ"))) + ("Jii" (("ఝీ"))) + ("jo" (("జో"))) + ("jO" (("జౌ"))) + ("Jo" (("ఝో") ("జౌ") ("జో"))) + ("JO" (("ఝౌ"))) + ("joo" (("జూ"))) + ("Joo" (("ఝూ") ("జూ") ("ఝౌ"))) + ("jou" (("జే"))) + ("Jou" (("ఝే"))) + ("jR" (("జృ"))) + ("JR" (("ఝృ") ("జే.ఆర్‍"))) + ("ju" (("జు"))) + ("jU" (("జూ"))) + ("Ju" (("ఝు") ("జు"))) + ("JU" (("ఝూ") ("జే.యు."))) + ("juu" (("జూ"))) + ("Juu" (("ఝూ") ("జూ"))) + ("k^" (("క్"))) + ("k" (("క్") ("క్క్") ("కే"))) + ("K^" (("ఖ్"))) + ("K" (("ఖ్") ("కే"))) + ("ka" (("క") ("గ") ("ఖ") ("ఘ"))) + ("kA" (("కా"))) + ("Ka" (("ఖ") ("క") ("క్క"))) + ("KA" (("ఖా"))) + ("kaa" (("కా") ("గా"))) + ("Kaa" (("ఖా"))) + ("kae" (("కై"))) + ("Kae" (("ఖై"))) + ("kaH" (("కః"))) + ("KaH" (("ఖః"))) + ("kai" (("కై") ("కయ్"))) + ("Kai" (("ఖై"))) + ("kaM" (("కఁ"))) + ("KaM" (("ఖఁ"))) + ("kau" (("కౌ") ("కే"))) + ("Kau" (("ఖౌ"))) + ("ke" (("కే"))) + ("kE" (("కై"))) + ("Ke" (("ఖే") ("కే"))) + ("KE" (("ఖై"))) + ("kee" (("కీ"))) + ("Kee" (("ఖి") ("కి"))) + ("kei" (("కై") ("కేయ్"))) + ("Kei" (("ఖై"))) + ("kh^" (("ఖ్"))) + ("kh" (("ఖ్") ("ఘ్"))) + ("kha" (("ఖ") ("క్క") ("ఘ"))) + ("khA" (("ఖా"))) + ("khaa" (("ఖా"))) + ("khae" (("ఖై"))) + ("khaH" (("ఖః"))) + ("khai" (("ఖై"))) + ("khaM" (("ఖఁ"))) + ("khau" (("ఖౌ") ("ఖే"))) + ("khe" (("ఖే"))) + ("khE" (("ఖై"))) + ("khee" (("ఖి"))) + ("khei" (("ఖై"))) + ("khi" (("ఖి") ("క్కి"))) + ("khI" (("ఖి"))) + ("khii" (("ఖి"))) + ("kho" (("ఖో"))) + ("khO" (("ఖౌ"))) + ("khoo" (("ఖూ"))) + ("khou" (("ఖే"))) + ("khR" (("ఖృ"))) + ("khu" (("ఖు") ("ఘు"))) + ("khU" (("ఖూ"))) + ("khuu" (("ఖూ"))) + ("ki" (("కి") ("గి") ("ఘి") ("ఖి") ("కై"))) + ("Ki" (("ఖి") ("కి"))) + ("KI" (("ఖ"))) + ("ko" (("కో"))) + ("kO" (("కో"))) + ("Ko" (("ఖో") ("కో") ("కౌ"))) + ("KO" (("ఖౌ"))) + ("koo" (("కూ") ("క"))) + ("Koo" (("ఖూ") ("కూ") ("కౌ"))) + ("kou" (("కే"))) + ("Kou" (("ఖే"))) + ("kR" (("కృ"))) + ("KR" (("ఖృ"))) + ("ku" (("కు") ("కూ"))) + ("kU" (("కూ"))) + ("Ku" (("ఖు") ("కు"))) + ("KU" (("ఖూ"))) + ("kuu" (("కూ"))) + ("Kuu" (("ఖూ") ("కూ"))) + ("l^" (("ల్"))) + ("l~" (("ల్"))) + ("l_" (("ల్"))) + ("l" (("ల్") ("ల్") ("ల్") ("ఏల్‍"))) + ("L^" (("ల్"))) + ("L~" (("ల్"))) + ("L_" (("ల్"))) + ("L" (("ల్") ("ల్") ("ఏల్‍") ("ల్ల్"))) + ("la" (("ల") ("ల"))) + ("lA" (("లా"))) + ("La" (("ల") ("ల"))) + ("LA" (("లా"))) + ("laa" (("లా") ("లా"))) + ("Laa" (("లా") ("లా"))) + ("lae" (("లై"))) + ("Lae" (("లై") ("లై"))) + ("laH" (("లః"))) + ("LaH" (("లః"))) + ("lai" (("లై"))) + ("Lai" (("లై"))) + ("laM" (("లఁ"))) + ("LaM" (("లఁ"))) + ("lau" (("లౌ"))) + ("Lau" (("లౌ") ("లౌ") ("లే"))) + ("le" (("లే") ("లే"))) + ("lE" (("లై"))) + ("Le" (("లే") ("లే"))) + ("LE" (("లై") ("లై"))) + ("lee" (("లీ") ("లీ"))) + ("Lee" (("లీ") ("లీ"))) + ("lei" (("లై"))) + ("Lei" (("లై"))) + ("li" (("లి") ("లి") ("లై") ("లై"))) + ("lI" (("లీ"))) + ("Li" (("లి") ("లి"))) + ("LI" (("లీ"))) + ("lii" (("లీ"))) + ("Lii" (("లీ"))) + ("lo" (("లో") ("లౌ"))) + ("lO" (("లౌ"))) + ("Lo" (("లో") ("లౌ") ("లో"))) + ("LO" (("లౌ"))) + ("loo" (("లూ") ("లౌ"))) + ("Loo" (("లూ") ("లూ"))) + ("lou" (("లే"))) + ("Lou" (("లే"))) + ("lR" (("లృ"))) + ("LR" (("లృ"))) + ("lu" (("లు") ("లు"))) + ("lU" (("లూ"))) + ("Lu" (("లు") ("లు"))) + ("LU" (("లూ"))) + ("luu" (("లూ"))) + ("Luu" (("లూ") ("లూ"))) + ("m^" (("మ్"))) + ("m~" (("ఁ"))) + ("m_" (("ఁ"))) + ("ma" (("మ") ("మ్మ"))) + ("mA" (("మా"))) + ("maa" (("మా"))) + ("mae" (("మై"))) + ("maH" (("మః"))) + ("mai" (("మై") ("మయ్"))) + ("maM" (("మఁ"))) + ("mau" (("మౌ") ("మే"))) + ("me" (("మే"))) + ("mE" (("మై"))) + ("mee" (("మీ"))) + ("mei" (("మేయ్") ("మై"))) + ("mi" (("మి"))) + ("mI" (("మి"))) + ("mii" (("మీ"))) + ("mo" (("మో") ("మౌ"))) + ("mO" (("మౌ"))) + ("moo" (("మూ") ("మౌ"))) + ("mou" (("మే"))) + ("mR" (("మృ"))) + ("mu" (("ము"))) + ("mU" (("మూ"))) + ("muu" (("మూ"))) + ("n^" (("న్"))) + ("n~" (("న్"))) + ("n_" (("న్"))) + ("n" (("న్") ("న్") ("ణ్") ("ణ్") ("న్న్") ("ఏన్‍"))) + ("N^" (("ణ్"))) + ("N~" (("ణ్"))) + ("N_" (("ణ్"))) + ("N" (("ణ్") ("ణ్") ("ణ్ణ్") ("న్") ("ఏన్‍"))) + ("na" (("న") ("ణ"))) + ("nA" (("నా"))) + ("Na" (("ణ") ("న") ("నా") ("ణ్ణ"))) + ("NA" (("ణా"))) + ("naa" (("నా") ("ణా"))) + ("Naa" (("ణా") ("నా"))) + ("nae" (("నై"))) + ("Nae" (("ణై"))) + ("naH" (("నః"))) + ("NaH" (("ణః"))) + ("nai" (("నై") ("నాయ్"))) + ("Nai" (("ణై"))) + ("naM" (("నఁ"))) + ("NaM" (("ణఁ"))) + ("nau" (("నౌ") ("నౌ"))) + ("Nau" (("ణౌ") ("ణే"))) + ("ne" (("నే") ("న్") ("ణ్"))) + ("nE" (("నై"))) + ("Ne" (("ణే"))) + ("NE" (("ణై"))) + ("nee" (("నీ"))) + ("Nee" (("ణీ") ("ణై") ("ని"))) + ("nei" (("నేయ్") ("నై"))) + ("Nei" (("ణై"))) + ("ng^" (("ఙ్"))) + ("ng" (("ఙ్"))) + ("nga" (("ఙ") ("ఙ్ఙ"))) + ("ngA" (("ఙా"))) + ("ngaa" (("ఙా"))) + ("ngaM" (("ఙఁ"))) + ("ngau" (("ఙౌ"))) + ("nge" (("ఙే"))) + ("ngE" (("ఙై"))) + ("ngee" (("ఙీ"))) + ("ngei" (("ఙై"))) + ("ngi" (("ఙి"))) + ("ngii" (("ఙీ"))) + ("ngo" (("ఙో"))) + ("ngO" (("ఙౌ"))) + ("ngoo" (("ఙూ"))) + ("ngou" (("ఙే"))) + ("ngR" (("ఙృ"))) + ("ngu" (("ఙు"))) + ("nguu" (("ఙూ"))) + ("ni" (("ని") ("ణి") ("నై"))) + ("nI" (("నీ") ("ణీ"))) + ("Ni" (("ణి") ("ణ్ణి"))) + ("NI" (("ణీ"))) + ("nii" (("నీ") ("ణీ"))) + ("Nii" (("ణీ"))) + ("nj^" (("ఞ్"))) + ("nj" (("ఞ్") ("ఞ్ఞ్"))) + ("nja" (("ఞ") ("ఞ్చ") ("ఞ్ఞ"))) + ("njA" (("ఞా"))) + ("njaa" (("ఞా") ("ఞ్చా"))) + ("njae" (("ఞై") ("ఞ్ఞై"))) + ("njaH" (("ఞః"))) + ("njai" (("ఞై") ("ఞ్ఞై"))) + ("njaM" (("ఞఁ"))) + ("njau" (("ఞౌ") ("ఞే") ("ఞ్ఞౌ"))) + ("nje" (("ఞే") ("ఞ్ఞే") ("ఞ్చే"))) + ("njE" (("ఞై") ("ఞ్ఞై"))) + ("njee" (("ఞీ") ("ఞ్చీ"))) + ("njei" (("ఞ్చై") ("ఞై") ("ఞ్ఞై"))) + ("nji" (("ఞి") ("ఞ్ఞి") ("ఞ్చి"))) + ("njI" (("ఞి"))) + ("njii" (("ఞీ"))) + ("njo" (("ఞో") ("ఞ్ఞౌ") ("ఞ్చో"))) + ("njO" (("ఞౌ") ("ఞ్ఞౌ") ("ఞ్చౌ"))) + ("njoo" (("ఞూ") ("ఞ్ఞూ"))) + ("njou" (("ఞే"))) + ("njR" (("ఞృ"))) + ("nju" (("ఞు") ("ఞ్ఞు") ("ఞ్చు"))) + ("njU" (("ఞూ"))) + ("njuu" (("ఞూ") ("ఞ్ఞూ") ("ఞ్చూ"))) + ("no" (("నో") ("ణో") ("నౌ"))) + ("nO" (("నౌ"))) + ("No" (("ణో") ("నౌ"))) + ("NO" (("ణౌ"))) + ("noo" (("నూ") ("ణూ"))) + ("Noo" (("ణూ"))) + ("nou" (("నౌ"))) + ("Nou" (("ణే"))) + ("nR" (("నృ"))) + ("NR" (("ణృ"))) + ("nu" (("ను") ("ణు") ("ణ్"))) + ("nU" (("నూ") ("ణూ"))) + ("Nu" (("ణు"))) + ("NU" (("ణూ"))) + ("nuu" (("నూ") ("ణూ"))) + ("Nuu" (("ణూ"))) + ("@o" (("ొ"))) + ("o" (("ఓ"))) + ("O" (("ఔ"))) + ("oo" (("ఊ") ("ఔ"))) + ("ou" (("ఔ"))) + ("p^" (("ప్"))) + ("p" (("ప్") ("ప్ప్") ("పి"))) + ("pa" (("ప"))) + ("pA" (("పా"))) + ("Pa" (("ప"))) + ("paa" (("పా"))) + ("pae" (("పై"))) + ("paH" (("పః"))) + ("pai" (("పై") ("పయ్") ("పాయ్"))) + ("paM" (("పఁ"))) + ("pau" (("పౌ") ("పౌ"))) + ("pe" (("పే") ("పి"))) + ("pE" (("పై"))) + ("pee" (("పి") ("పై"))) + ("Pee" (("పి"))) + ("pei" (("పేయ్") ("పై"))) + ("ph^" (("ఫ్"))) + ("ph" (("ఫ్") ("పి.ఏచ్."))) + ("pha" (("ఫ"))) + ("phA" (("ఫా"))) + ("phaa" (("ఫా"))) + ("phaH" (("ఫః"))) + ("phai" (("ఫై"))) + ("phaM" (("ఫఁ"))) + ("phau" (("ఫౌ") ("ఫే"))) + ("phe" (("ఫే"))) + ("phE" (("ఫై"))) + ("phee" (("ఫి"))) + ("phei" (("ఫై"))) + ("phi" (("ఫి"))) + ("phI" (("ఫీ"))) + ("phii" (("ఫి"))) + ("pho" (("ఫో") ("ఫౌ"))) + ("phO" (("ఫౌ"))) + ("phoo" (("ఫూ"))) + ("phou" (("ఫే"))) + ("phR" (("ఫృ"))) + ("phu" (("ఫు"))) + ("phU" (("ఫూ"))) + ("phuu" (("ఫూ"))) + ("pi" (("పి") ("పై") ("ప్పి"))) + ("pI" (("పి"))) + ("po" (("పో"))) + ("pO" (("పౌ"))) + ("poo" (("పూ") ("పౌ"))) + ("Poo" (("పూ"))) + ("pou" (("పౌ"))) + ("pR" (("పృ"))) + ("pu" (("పు"))) + ("pU" (("పూ"))) + ("Pu" (("పు"))) + ("puu" (("పూ"))) + ("q" (("క్యు"))) + ("Q" (("క్యూ"))) + ("r^" (("ఋ"))) + ("r~" (("ర్"))) + ("r_" (("ర్"))) + ("r" (("ర్") ("ర్") ("ఆర"))) + ("R^" (("ర్"))) + ("R~" (("ర్"))) + ("R_" (("ర్"))) + ("R" (("ర్") ("ర్") ("ఆర"))) + ("ra" (("ర") ("ర"))) + ("rA" (("రా"))) + ("Ra" (("ర") ("ర") ("రా"))) + ("RA" (("రా"))) + ("raa" (("రా") ("రా"))) + ("Raa" (("రా"))) + ("rae" (("రై"))) + ("Rae" (("రై"))) + ("raH" (("రః"))) + ("RaH" (("రః"))) + ("rai" (("రై") ("రాయ్"))) + ("Rai" (("రై") ("రాయ్"))) + ("raM" (("రఁ"))) + ("RaM" (("రఁ"))) + ("rau" (("రౌ"))) + ("Rau" (("రౌ"))) + ("re" (("రే"))) + ("rE" (("రై"))) + ("Re" (("రే"))) + ("RE" (("రై"))) + ("ree" (("రీ"))) + ("Ree" (("రీ") ("రీ") ("రై"))) + ("rei" (("రై") ("రేయ్"))) + ("Rei" (("రై") ("రేయ్"))) + ("ri" (("రి") ("రి") ("రై") ("రై"))) + ("rI" (("రి"))) + ("Ri" (("రి") ("రి"))) + ("RI" (("రి"))) + ("rii" (("రీ"))) + ("Rii" (("రీ"))) + ("ro" (("రో") ("రౌ"))) + ("rO" (("రౌ"))) + ("Ro" (("రో"))) + ("RO" (("రౌ"))) + ("roo" (("రూ"))) + ("Roo" (("రూ") ("రూ"))) + ("rou" (("రౌ"))) + ("Rou" (("రౌ"))) + ("rr" (("ఋ"))) + ("rR" (("రృ"))) + ("RR" (("ఋ"))) + ("ru" (("రు") ("రు"))) + ("rU" (("రూ"))) + ("Ru" (("రు") ("రు"))) + ("RU" (("రూ"))) + ("ruu" (("రూ"))) + ("Ruu" (("రూ") ("రూ"))) + ("s^" (("స్"))) + ("s" (("స్") ("శ్") ("స్స్") ("ఏస్"))) + ("S^" (("శ్"))) + ("S" (("శ్") ("స్") ("శ్శ్") ("ఏస్"))) + ("sa" (("స") ("శ"))) + ("sA" (("సా"))) + ("Sa" (("శ") ("స"))) + ("SA" (("శా") ("సా"))) + ("saa" (("సా") ("శా"))) + ("Saa" (("శా") ("సా"))) + ("sae" (("సై"))) + ("Sae" (("శై"))) + ("saH" (("సః"))) + ("SaH" (("శః") ("షా"))) + ("sai" (("సై") ("సాయ్"))) + ("Sai" (("శై") ("సై") ("సాయ"))) + ("saM" (("సఁ"))) + ("SaM" (("శఁ"))) + ("sau" (("సౌ") ("సే"))) + ("Sau" (("శౌ") ("సౌ"))) + ("se" (("సే") ("సి"))) + ("sE" (("సై"))) + ("Se" (("శే") ("సే") ("సి"))) + ("SE" (("శై") ("ఏస.ఇ."))) + ("see" (("సీ") ("శీ"))) + ("See" (("శి") ("సి"))) + ("sei" (("సై"))) + ("Sei" (("శై") ("సి"))) + ("sh^" (("ష్"))) + ("sh" (("ష్"))) + ("Sh^" (("ష్"))) + ("Sh" (("ష్") ("ష్"))) + ("sha" (("ష"))) + ("shA" (("షా"))) + ("Sha" (("ష") ("ష") ("షా"))) + ("ShA" (("షా"))) + ("shaa" (("షా"))) + ("Shaa" (("షా"))) + ("shae" (("షై"))) + ("Shae" (("షై"))) + ("shaH" (("షః"))) + ("ShaH" (("షః"))) + ("shai" (("షై"))) + ("Shai" (("షై"))) + ("shaM" (("షఁ"))) + ("ShaM" (("షఁ"))) + ("shau" (("షౌ") ("షే"))) + ("Shau" (("షౌ") ("షౌ") ("షే"))) + ("she" (("షే") ("షి"))) + ("shE" (("షై"))) + ("She" (("షే") ("షి"))) + ("ShE" (("షై"))) + ("shee" (("షీ") ("షీ"))) + ("Shee" (("షీ"))) + ("shei" (("షై"))) + ("Shei" (("షై"))) + ("shi" (("షి"))) + ("shI" (("షీ"))) + ("Shi" (("షి"))) + ("ShI" (("షీ"))) + ("shii" (("షీ"))) + ("Shii" (("షీ"))) + ("sho" (("షో") ("షౌ"))) + ("shO" (("షౌ"))) + ("Sho" (("షో"))) + ("ShO" (("షౌ"))) + ("shoo" (("షూ"))) + ("Shoo" (("షూ") ("షూ"))) + ("shou" (("షే"))) + ("Shou" (("షే"))) + ("shR" (("షృ"))) + ("ShR" (("షృ"))) + ("shu" (("షు"))) + ("shU" (("షూ"))) + ("Shu" (("షు") ("షు"))) + ("ShU" (("షూ"))) + ("shuu" (("షూ"))) + ("Shuu" (("షూ"))) + ("si" (("సి") ("శి"))) + ("sI" (("సీ"))) + ("Si" (("శి") ("సి"))) + ("SI" (("శీ") ("ఏస్.ఐ."))) + ("sii" (("సీ"))) + ("Sii" (("శి"))) + ("so" (("సో") ("శో") ("సౌ"))) + ("sO" (("సౌ"))) + ("So" (("శో") ("సో") ("సౌ"))) + ("SO" (("శౌ"))) + ("soo" (("సూ") ("శూ"))) + ("Soo" (("శూ") ("సూ"))) + ("sou" (("సే"))) + ("Sou" (("శే") ("సే"))) + ("sR" (("సృ"))) + ("SR" (("శృ") ("ఏస.ఆర"))) + ("su" (("సు") ("శు"))) + ("sU" (("సూ"))) + ("Su" (("శు") ("సు"))) + ("SU" (("శూ"))) + ("suu" (("సూ") ("శూ"))) + ("Suu" (("శూ"))) + ("t" (("ట్") ("ట్ట్") ("ర్ర్") ("త్") ("టి"))) + ("t^" (("ట్"))) + ("T^" (("ఠ్"))) + ("T" (("ఠ్") ("టి"))) + ("ta" (("ట") ("ర్ర") ("ఠ"))) + ("tA" (("టా"))) + ("Ta" (("ఠ") ("ట") ("త"))) + ("TA" (("ఠా"))) + ("taa" (("టా"))) + ("Taa" (("ఠా"))) + ("tae" (("టై"))) + ("Tae" (("ఠై"))) + ("taH" (("టః"))) + ("TaH" (("ఠః"))) + ("tai" (("టై") ("టాయ్"))) + ("Tai" (("ఠై"))) + ("taM" (("టఁ"))) + ("TaM" (("ఠఁ"))) + ("tau" (("టౌ") ("టే"))) + ("Tau" (("ఠౌ") ("ఠే"))) + ("te" (("టే") ("ర్రే") ("ఠే"))) + ("tE" (("టై"))) + ("Te" (("ఠే") ("టే") ("తే"))) + ("TE" (("ఠై"))) + ("tea" (("టీ") ("ర్రి"))) + ("tee" (("టీ") ("ర్రీ"))) + ("Tee" (("ఠీ"))) + ("tei" (("టై") ("టేయ్"))) + ("Tei" (("ఠై"))) + ("th^" (("త్"))) + ("th" (("త్") ("త్త్"))) + ("Th^" (("థ్"))) + ("Th" (("థ్"))) + ("tha" (("త") ("ధ") ("త్త") ("ద్ధ") ("థ"))) + ("thA" (("తా"))) + ("Tha" (("థ") ("త"))) + ("ThA" (("థా"))) + ("thaa" (("తా") ("త్తా"))) + ("Thaa" (("థా") ("తా"))) + ("thae" (("తై"))) + ("Thae" (("థై"))) + ("thaH" (("తః"))) + ("ThaH" (("థః"))) + ("thai" (("తై"))) + ("Thai" (("థై") ("తై"))) + ("thaM" (("తఁ") ("త్తఁ"))) + ("ThaM" (("థఁ"))) + ("thau" (("తౌ") ("తే"))) + ("Thau" (("థౌ") ("థే"))) + ("the" (("తే"))) + ("thE" (("తై"))) + ("The" (("థే") ("ది") ("తే"))) + ("ThE" (("థై"))) + ("thee" (("తీ") ("తై"))) + ("Thee" (("థి") ("తి"))) + ("thei" (("తై") ("తేయ్"))) + ("Thei" (("థై") ("తేయ్"))) + ("thi" (("తి") ("త్తి") ("త్థి") ("థి") ("ధి") ("ద్ధి") ("తై"))) + ("thI" (("తీ"))) + ("Thi" (("థి") ("తి") ("త్థి"))) + ("ThI" (("థీ"))) + ("thii" (("తీ") ("త్తీ"))) + ("Thii" (("థి"))) + ("tho" (("తో") ("తౌ") ("త్తో"))) + ("thO" (("తౌ") ("త్తౌ"))) + ("Tho" (("థో"))) + ("ThO" (("థౌ"))) + ("thoo" (("తూ") ("తౌ"))) + ("Thoo" (("థూ") ("తూ"))) + ("thou" (("తే"))) + ("Thou" (("థే"))) + ("thR" (("తృ"))) + ("ThR" (("థృ") ("తృ"))) + ("thu" (("తు") ("త్తు"))) + ("thU" (("తూ"))) + ("Thu" (("థు") ("తు"))) + ("ThU" (("థూ") ("తూ"))) + ("thuu" (("తూ"))) + ("Thuu" (("థూ") ("తూ"))) + ("ti" (("టి") ("ట్టి") ("ర్రి") ("ఠి") ("టై"))) + ("tI" (("టీ") ("ర్రీ"))) + ("Ti" (("ఠి") ("టి") ("తి") ("తై"))) + ("TI" (("ఠీ"))) + ("tii" (("టీ"))) + ("Tii" (("ఠీ"))) + ("to" (("టో") ("టు") ("ర్రు"))) + ("tO" (("టౌ"))) + ("To" (("ఠో") ("టు") ("తో"))) + ("TO" (("ఠౌ"))) + ("too" (("టూ") ("ర్రూ"))) + ("Too" (("ఠూ") ("టూ"))) + ("tou" (("టే"))) + ("Tou" (("ఠే"))) + ("tR" (("టృ"))) + ("TR" (("ఠృ"))) + ("TT" (("టి.టి."))) + ("TTa" (("ట్ట"))) + ("TTI" (("టి.టి.ఐ."))) + ("TTR" (("టి.టి.ఆర్‍."))) + ("tu" (("టు") ("ర్రు") ("ట్టు"))) + ("tU" (("టూ") ("ర్రూ"))) + ("Tu" (("ఠు") ("టు"))) + ("TU" (("ఠూ"))) + ("tuu" (("టూ") ("ర్రూ"))) + ("Tuu" (("ఠూ"))) + ("u" (("ఉ") ("ఊ") ("యు"))) + ("U" (("ఊ"))) + ("v^" (("వ్"))) + ("v" (("వ్") ("వ్వ్") ("వి"))) + ("V" (("వి"))) + ("va" (("వ") ("వా"))) + ("vA" (("వా"))) + ("Va" (("వ") ("వ్వ") ("వా"))) + ("vaa" (("వా"))) + ("Vaa" (("వా"))) + ("vae" (("వై"))) + ("vaH" (("వః"))) + ("vai" (("వై") ("వయ్"))) + ("vaM" (("వఁ"))) + ("vau" (("వౌ") ("వే"))) + ("ve" (("వే"))) + ("vE" (("వై"))) + ("vee" (("వి") ("వై"))) + ("vei" (("వైయ్") ("వై"))) + ("vi" (("వి"))) + ("vI" (("వి"))) + ("Vi" (("వి"))) + ("vii" (("వి"))) + ("vo" (("వో") ("వౌ"))) + ("vO" (("వౌ"))) + ("voo" (("వూ"))) + ("vou" (("వే"))) + ("vR" (("వృ"))) + ("vu" (("వు"))) + ("vU" (("వూ"))) + ("vuu" (("వూ"))) + ("w^" (("వ్"))) + ("w" (("వ్") ("వ్వ్") ("డబ్ల్యూ"))) + ("wa" (("వ"))) + ("wA" (("వా"))) + ("waa" (("వా"))) + ("wae" (("వై"))) + ("waH" (("వః"))) + ("wai" (("వై"))) + ("waM" (("వఁ"))) + ("wau" (("వౌ"))) + ("we" (("వే"))) + ("wE" (("వై"))) + ("wee" (("వి"))) + ("wei" (("వై"))) + ("wi" (("వి"))) + ("wI" (("వి"))) + ("wii" (("వి"))) + ("wo" (("వో"))) + ("wO" (("వౌ"))) + ("woo" (("వూ"))) + ("wou" (("వే"))) + ("wR" (("వృ"))) + ("wu" (("వు"))) + ("wU" (("వూ"))) + ("wuu" (("వూ"))) + ("x^" (("క్ష్"))) + ("x" (("క్ష్") ("క్స్") ("ఏక్స్"))) + ("X" (("ఏక్స్"))) + ("xa" (("క్ష") ("క్స") ("క్సే"))) + ("xA" (("క్షా"))) + ("xaa" (("క్షా"))) + ("xaH" (("క్షః"))) + ("xai" (("క్షై"))) + ("xaM" (("క్షఁ"))) + ("xau" (("క్షౌ") ("క్షే"))) + ("xe" (("క్షే") ("క్షై") ("క్సే") ("క్సి") ("క్షి"))) + ("xE" (("క్షై"))) + ("xee" (("క్షీ"))) + ("xei" (("క్షై"))) + ("xi" (("క్షి") ("క్సి"))) + ("xI" (("క్షీ"))) + ("xii" (("క్షీ"))) + ("xo" (("క్షో"))) + ("xO" (("క్షౌ"))) + ("xoo" (("క్షూ"))) + ("xou" (("క్షే"))) + ("xR" (("క్షృ"))) + ("xu" (("క్షు") ("క్సు"))) + ("xU" (("క్షూ"))) + ("xuu" (("క్షూ"))) + ("y^" (("య్"))) + ("y" (("య్") ("య్య్") ("వై"))) + ("Y" (("వై"))) + ("ya" (("య"))) + ("yA" (("యా"))) + ("Ya" (("య"))) + ("YA" (("యా"))) + ("yaa" (("యా"))) + ("Yaa" (("యా"))) + ("yae" (("యై"))) + ("yaH" (("యః") ("యః"))) + ("yai" (("యై"))) + ("Yai" (("యై"))) + ("yaM" (("యఁ") ("యఁ"))) + ("yau" (("యౌ") ("యే"))) + ("Yau" (("యౌ") ("యే"))) + ("ye" (("యే") ("యై"))) + ("yE" (("యై"))) + ("Ye" (("యే") ("యై"))) + ("YE" (("యై") ("యై"))) + ("yei" (("యై"))) + ("Yei" (("యై"))) + ("yi" (("యి"))) + ("yI" (("యి"))) + ("Yi" (("యి"))) + ("YI" (("యీ"))) + ("yii" (("యీ"))) + ("Yii" (("యీ"))) + ("yo" (("యో"))) + ("yO" (("యౌ"))) + ("Yo" (("యో") ("యౌ"))) + ("YO" (("యౌ"))) + ("yoo" (("యూ"))) + ("Yoo" (("యూ"))) + ("you" (("యే") ("యూ") ("యూ") ("యే"))) + ("yR" (("యృ"))) + ("YR" (("యృ"))) + ("yu" (("యు"))) + ("yU" (("యూ"))) + ("Yu" (("యు"))) + ("YU" (("యూ"))) + ("yuu" (("యూ"))) + ("Yuu" (("యూ"))) + ("z^" (("శ్"))) + ("z" (("శ్") ("స్") ("ఇసడ్"))) + ("za" (("శ") ("స"))) + ("zA" (("శా"))) + ("zaa" (("శా") ("సా"))) + ("zaH" (("శః"))) + ("zai" (("శై"))) + ("zaM" (("శఁ"))) + ("zau" (("శౌ"))) + ("ze" (("శే"))) + ("zE" (("శై"))) + ("zee" (("శీ") ("సీ"))) + ("zei" (("శై"))) + ("zh^" (("ష్"))) + ("zh" (("ష్"))) + ("zha" (("ష"))) + ("zhA" (("షా"))) + ("zhaa" (("షా"))) + ("zhae" (("షై"))) + ("zhaH" (("షః"))) + ("zhai" (("షై"))) + ("zhaM" (("షఁ"))) + ("zhau" (("షౌ") ("షే"))) + ("zhe" (("షే"))) + ("zhE" (("షై"))) + ("zhee" (("షీ"))) + ("zhei" (("షై"))) + ("zhi" (("షి"))) + ("zhI" (("షీ"))) + ("zhii" (("షీ"))) + ("zho" (("షో"))) + ("zhO" (("షౌ"))) + ("zhoo" (("షూ"))) + ("zhou" (("షే"))) + ("zhR" (("షృ"))) + ("zhu" (("షు"))) + ("zhU" (("షూ"))) + ("zhuu" (("షూ"))) + ("zi" (("శి") ("సి"))) + ("zI" (("శీ"))) + ("zii" (("శీ"))) + ("zo" (("శో"))) + ("zO" (("శౌ"))) + ("zoo" (("శూ") ("సూ"))) + ("zou" (("శే"))) + ("zR" (("శృ"))) + ("zu" (("శు") ("సు"))) + ("zU" (("శూ"))) + ("zuu" (("శూ"))) +) +) + +(map + ;; Typing 1, 2, ..., 0 selects the 0th, 1st, ..., 9th candidate. + (choose + ("1" (select 0)) + ("2" (select 1)) + ("3" (select 2)) + ("4" (select 3)) + ("5" (select 4)) + ("6" (select 5)) + ("7" (select 6)) + ("8" (select 7)) + ("9" (select 8)) + ("0" (select 9))) + + (change-candidate + ((Left) (select @-)) + ((C-b) (select @-)) + ((Right) (select @+)) + ((C-f) (select @+)) + ((Up) (select @-)) + ((C-p) (select @-)) + ((Down) (select @+)) + ((C-n) (select @+))) + + (focus-change + ;; When an input spot is moved, commit the current predit by shifting + ;; to init. + ((input-focus-move) (shift init)) + ;; When an input focus is out or in, keep the current preedit. + ((input-focus-out) (set KK @@) (sub KK 1) (undo KK)) + ((input-focus-in) (set KK @@) (sub KK 1) (undo KK))) + + (backspace + ((BackSpace))) + + (commit-preedit + ((S-\ )))) + + +(state + ;; When an initial character is typed, re-handle it in "main" state. + (init + (starter (show) (pushback 1) (shift main))) + + (main + ;; When a complete sequence is typed, shift to "select" state + ;; to allow users to select one from the candidates. + (map (shift select)) + (nil (hide) (shift check-undo))) + + (check-undo + ;; When Backspace is typed, cancel the last input. + (backspace (undo)) + (focus-change) + ;; When anything else is typed, produce the current candidate (if + ;; any), and re-handle the last input in "init" state. + (nil (hide) (shift init))) + + (select + (t (set K @@) (sub K 1)) + ;; When a number is typed, select the corresponding canidate, + ;; produce it, and shift to "init" state. + (focus-change) + (choose (hide) (shift init)) + (change-candidate) + (backspace (undo K)) + ;; When key to force committing, commit the current preedit. + (commit-preedit (shift init)) + ;; When anything else is typed, produce the current candidate, + ;; and re-handle the last input in "init" state. + (nil (hide) (shift init)))) + +;; Local Variables: +;; mode: lisp +;; coding: utf-8 +;; End: + |