diff options
Diffstat (limited to 'input-methods/m17n/swanalekha/or-swanalekha.mim')
| -rwxr-xr-x | input-methods/m17n/swanalekha/or-swanalekha.mim | 1469 |
1 files changed, 1469 insertions, 0 deletions
diff --git a/input-methods/m17n/swanalekha/or-swanalekha.mim b/input-methods/m17n/swanalekha/or-swanalekha.mim new file mode 100755 index 0000000..f2affca --- /dev/null +++ b/input-methods/m17n/swanalekha/or-swanalekha.mim @@ -0,0 +1,1469 @@ +(input-method or swanalekha) + +(description "Swanalekha Oriya input method") + + +(title "oriya") +(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" (("ା"))) + ("A" (("ଆ") ("ଏ"))) + ("@aa" (("ା"))) + ("aa" (("ଆ"))) + ("@ae" (("େ"))) + ("ae" (("ଏ"))) + ("@ah" (("ଃ"))) + ("@aH" (("ଃ"))) + ("aH" (("ଅଃ"))) + ("@ai" (("ୈ"))) + ("ai" (("ଐ"))) + ("@am" (("ଂ"))) + ("@aM" (("ଂ"))) + ("aM" (("ଅଂ"))) + ("@au" (("ୗ"))) + ("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" (("କ୍କ୍"))) + ("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" (("େ"))) + ("E" (("ଏ") ("ଇ"))) + ("@ee" (("ୀ"))) + ("ee" (("ଈ"))) + ("@ei" (("ୈ"))) + ("ei" (("ଐ"))) + ("f^" (("ଫ୍"))) + ("f" (("ଫ୍") ("ଫ୍"))) + ("F^" (("ଫ୍"))) + ("F" (("ଫ୍") ("ଫ୍"))) + ("fa" (("ଫ"))) + ("fA" (("ଫା"))) + ("Fa" (("ଫ"))) + ("FA" (("ଫା"))) + ("faa" (("ଫା"))) + ("Faa" (("ଫା"))) + ("faH" (("ଫଃ"))) + ("FaH" (("ଫଃ"))) + ("fai" (("ଫୈ"))) + ("Fai" (("ଫୈ"))) + ("faM" (("ଫଂ"))) + ("FaM" (("ଫଂ"))) + ("fau" (("ଫୗ") ("ଫୌ"))) + ("Fau" (("ଫୗ") ("ଫୌ"))) + ("fe" (("ଫେ"))) + ("fE" (("ଫେ"))) + ("Fe" (("ଫେ"))) + ("FE" (("ଫେ"))) + ("fee" (("ଫୀ"))) + ("Fee" (("ଫୀ"))) + ("fei" (("ଫୈ"))) + ("Fei" (("ଫୈ"))) + ("fi" (("ଫି"))) + ("fI" (("ଫୀ"))) + ("Fi" (("ଫି"))) + ("FI" (("ଫୀ"))) + ("fii" (("ଫୀ"))) + ("Fii" (("ଫୀ"))) + ("fo" (("ଫୋ"))) + ("fO" (("ଫୋ"))) + ("Fo" (("ଫୋ"))) + ("FO" (("ଫୋ"))) + ("foo" (("ଫୂ"))) + ("Foo" (("ଫୂ"))) + ("fou" (("ଫୌ"))) + ("Fou" (("ଫୌ"))) + ("fR" (("ଫୃ"))) + ("FR" (("ଫୃ"))) + ("fu" (("ଫୁ"))) + ("fU" (("ଫୂ"))) + ("Fu" (("ଫୁ"))) + ("FU" (("ଫୂ"))) + ("fuu" (("ଫୂ"))) + ("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" (("ି"))) + ("i" (("ଇ") ("ଈ") ("ଐ"))) + ("@I" (("ୀ"))) + ("I" (("ଈ") ("ଐ"))) + ("@ii" (("ୀ"))) + ("ii" (("ଈ"))) + ("j^" (("ଜ୍"))) + ("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" (("ଖି") ("କି"))) + ("KI" (("ଖ"))) + ("kii" (("କୀ"))) + ("Kii" (("ଖୀ"))) + ("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_" (("ଂ"))) + ("m" (("ମ୍") )) + ("M^" (("ମ୍"))) + ("M~" (("ଂ"))) + ("M_" (("ଂ"))) + ("M" (("ମ୍") )) + ("ma" (("ମ") ("ମ୍ମ"))) + ("mA" (("ମା"))) + ("Ma" (("ମ") ("ମ୍ମ"))) + ("MA" (("ମା"))) + ("maa" (("ମା"))) + ("Maa" (("ମା"))) + ("mae" (("ମେ"))) + ("Mae" (("ମେ"))) + ("maH" (("ମଃ"))) + ("MaH" (("ମଃ"))) + ("mai" (("ମୈ") ("ମଯ୍"))) + ("Mai" (("ମୈ") ("ମଯ୍"))) + ("maM" (("ମଂ"))) + ("MaM" (("ମଂ"))) + ("mau" (("ମୗ") ("ମୌ"))) + ("Mau" (("ମୗ") ("ମୌ"))) + ("me" (("ମେ"))) + ("mE" (("ମେ"))) + ("Me" (("ମେ"))) + ("ME" (("ମେ"))) + ("mee" (("ମୀ"))) + ("Mee" (("ମୀ"))) + ("mei" (("ମଯ୍") ("ମୈ"))) + ("Mei" (("ମଯ୍") ("ମୈ"))) + ("mi" (("ମି"))) + ("mI" (("ମୀ"))) + ("Mi" (("ମି"))) + ("MI" (("ମୀ"))) + ("mii" (("ମୀ"))) + ("Mii" (("ମୀ"))) + ("mo" (("ମ") ("ମୋ"))) + ("mO" (("ମୋ"))) + ("Mo" (("ମୋ") ("ମୋ"))) + ("MO" (("ମୋ"))) + ("moo" (("ମୂ") ("ମୋ"))) + ("Moo" (("ମୂ") ("ମୋ"))) + ("mou" (("ମୌ"))) + ("Mou" (("ମୌ"))) + ("mR" (("ମୃ"))) + ("MR" (("ମୃ"))) + ("mu" (("ମୁ"))) + ("mU" (("ମୂ"))) + ("Mu" (("ମୁ"))) + ("MU" (("ମୂ"))) + ("muu" (("ମୂ"))) + ("Muu" (("ମୂ"))) + ("n^" (("ନ୍"))) + ("n" (("ନ୍") ("ଣ୍") ("ଣ୍") ("ନ୍ନ୍"))) + ("N^" (("ଣ୍"))) + ("N" (("ଣ୍") ("ଣ୍ଣ୍") ("ନ୍"))) + ("na" (("ନ") ("ଣ"))) + ("nA" (("ନା"))) + ("Na" (("ଣ") ("ନ") ("ନା") ("ଣ୍ଣ"))) + ("NA" (("ଣା"))) + ("naa" (("ନା") ("ଣା"))) + ("Naa" (("ଣା") ("ନା"))) + ("nae" (("ନେ"))) + ("Nae" (("ଣେ"))) + ("naH" (("ନଃ"))) + ("NaH" (("ଣଃ"))) + ("nai" (("ନୈ") ("ନାଯ୍"))) + ("Nai" (("ଣୈ"))) + ("naM" (("ନଂ"))) + ("NaM" (("ଣଂ"))) + ("nau" (("ନୗ") ("ନୌ"))) + ("Nau" (("ଣୗ") ("ଣୌ"))) + ("nch^" (("ଞ୍ଚ୍"))) + ("nch" (("ଞ୍ଚ୍"))) + ("ncha" (("ଞ୍ଚ") ("ଞ୍ଚା"))) + ("nchA" (("ଞ୍ଚା"))) + ("nchaa" (("ଞ୍ଚା"))) + ("nchaH" (("ଞ୍ଚଃ"))) + ("nchai" (("ଞ୍ଚୈ"))) + ("nchaM" (("ଞ୍ଚଂ"))) + ("nchau" (("ଞ୍ଚୌ") ("ଞ୍ଚୌ"))) + ("nche" (("ଞ୍ଚେ") ("ଞ୍ଚିେ"))) + ("nchE" (("ଞ୍ଚେ"))) + ("nchee" (("ଞ୍ଚୀ"))) + ("nchei" (("ଞ୍ଚୈ"))) + ("nchi" (("ଞ୍ଚି"))) + ("nchI" (("ଞ୍ଚୀ"))) + ("nchii" (("ଞ୍ଚୀ"))) + ("ncho" (("ଞ୍ଚୋ"))) + ("nchO" (("ଞ୍ଚୋ"))) + ("nchoo" (("ଞ୍ଚୂ"))) + ("nchou" (("ଞ୍ଚୌ"))) + ("nchR" (("ଞ୍ଚୃ"))) + ("nchu" (("ଞ୍ଚୁ"))) + ("nchU" (("ଞ୍ଚୂ"))) + ("nchuu" (("ଞ୍ଚୂ"))) + ("ne" (("ନେ"))) + ("nE" (("ନେ"))) + ("Ne" (("ଣେ"))) + ("NE" (("ଣେ"))) + ("nee" (("ନୀ") ("ନେ"))) + ("Nee" (("ଣୀ") ("ନୀ") ("ଣେ") ("ନୀ"))) + ("nei" (("ନଯ୍") ("ନୈ"))) + ("Nei" (("ଣୈ"))) + ("ng^" (("ଙ୍"))) + ("ng" (("ଙ୍ଙ୍") ("ଙ୍"))) + ("nga" (("ଙ"))) + ("ngA" (("ଙା"))) + ("Nga" (("ଙ") ("ଙ୍ଙ"))) + ("NgA" (("ଙା"))) + ("ngaa" (("ଙା"))) + ("Ngaa" (("ଙା"))) + ("ngae" (("ଙେ"))) + ("ngai" (("ଙୈ"))) + ("Ngai" (("ଙୈ"))) + ("ngaM" (("ଙଂ"))) + ("ngau" (("ଙୗ"))) + ("Ngau" (("ଙୗ"))) + ("nge" (("ଙେ"))) + ("ngE" (("ଙେ"))) + ("Nge" (("ଙେ"))) + ("NgE" (("ଙେ"))) + ("ngee" (("ଙୀ"))) + ("Ngee" (("ଙୀ"))) + ("ngei" (("ଙୈ"))) + ("Ngei" (("ଙୈ"))) + ("ngi" (("ଙି"))) + ("ngI" (("ଙୀ"))) + ("Ngi" (("ଙି"))) + ("ngii" (("ଙୀ"))) + ("Ngii" (("ଙୀ"))) + ("ngo" (("ଙୋ"))) + ("ngO" (("ଙୋ"))) + ("Ngo" (("ଙୋ"))) + ("NgO" (("ଙୋ"))) + ("ngoo" (("ଙୂ"))) + ("Ngoo" (("ଙୂ"))) + ("ngou" (("ଙୌ") ("ଙୌ"))) + ("Ngou" (("ଙୌ"))) + ("ngR" (("ଙୃ"))) + ("NgR" (("ଙୃ"))) + ("ngu" (("ଙୁ"))) + ("ngU" (("ଙୂ"))) + ("Ngu" (("ଙୁ"))) + ("nguu" (("ଙୂ"))) + ("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" (("ଞୂ") ("ଞ୍ଞୂ") ("ଞ୍ଚୂ"))) + ("nk^" (("ଙ୍କ୍"))) + ("nk" (("ଙ୍କ୍"))) + ("nka" (("ଙ୍କ"))) + ("nkA" (("ଙ୍କା"))) + ("nkaa" (("ଙ୍କା"))) + ("nkaH" (("ଙ୍କଃ"))) + ("nkai" (("ଙ୍କୈ") ("ଙ୍କାଯ୍"))) + ("nkaM" (("ଙ୍କଂ"))) + ("nkau" (("ଙ୍କୗ") ("ଙ୍କୌ"))) + ("nke" (("ଙ୍କେ"))) + ("nkE" (("ଙ୍କେ"))) + ("nkee" (("ଙ୍କୀ"))) + ("nkei" (("ଙ୍କୈ"))) + ("nki" (("ଙ୍କି"))) + ("nkI" (("ଙ୍କୀ"))) + ("nkii" (("ଙ୍କୀ"))) + ("nko" (("ଙ୍କୋ") ("ଙ୍କୋ"))) + ("nkO" (("ଙ୍କୋ"))) + ("nkoo" (("ଙ୍କୂ"))) + ("nkou" (("ଙ୍କୌ"))) + ("nkR" (("ଙ୍କୃ"))) + ("nku" (("ଙ୍କୁ"))) + ("nkU" (("ଙ୍କୂ"))) + ("nkuu" (("ଙ୍କୂ"))) + ("no" (("ନୋ") ("ଣୋ") ("ନୋ"))) + ("nO" (("ନୋ"))) + ("No" (("ଣୋ") ("ନୋ"))) + ("NO" (("ଣୋ") ("ନୋ"))) + ("noo" (("ନୂ") ("ଣୂ"))) + ("Noo" (("ଣୂ") ("ନୂ"))) + ("nou" (("ନୌ"))) + ("Nou" (("ଣୌ"))) + ("nR" (("ନୃ"))) + ("NR" (("ଣୃ"))) + ("nth^" (("ନ୍ତ୍"))) + ("nth" (("ନ୍ତ୍"))) + ("ntha" (("ନ୍ତ") ("ନ୍ଦ"))) + ("nthA" (("ନ୍ତା"))) + ("nthaa" (("ନ୍ତା"))) + ("nthaH" (("ନ୍ତଃ"))) + ("nthai" (("ନ୍ତୈ"))) + ("nthaM" (("ନ୍ତଂ"))) + ("nthau" (("ନ୍ତୗ") ("ନ୍ତୌ"))) + ("nthe" (("ନ୍ତେ"))) + ("nthE" (("ନ୍ତେ") )) + ("nthee" (("ନ୍ତୀ") ("ନ୍ଦୀ"))) + ("nthei" (("ନ୍ତୈ"))) + ("nthi" (("ନ୍ତି") ("ନ୍ଦି"))) + ("nthI" (("ନ୍ତୀ"))) + ("nthii" (("ନ୍ତୀ"))) + ("ntho" (("ନ୍ତୋ"))) + ("nthO" (("ନ୍ତୋ"))) + ("nthoo" (("ନ୍ତୂ"))) + ("nthou" (("ନ୍ତୌ"))) + ("nthR" (("ନ୍ତୃ"))) + ("nthu" (("ନ୍ତୁ"))) + ("nthU" (("ନ୍ତୂ"))) + ("nthuu" (("ନ୍ତୂ"))) + ("nu" (("ନୁ") ("ଣୁ") ("ଣ୍"))) + ("nU" (("ନୂ") ("ଣୂ"))) + ("Nu" (("ଣୁ"))) + ("NU" (("ଣୂ"))) + ("nuu" (("ନୂ") ("ଣୂ"))) + ("Nuu" (("ଣୂ") ("ନୂ"))) + ("@o" (("ୋ"))) + ("o" (("ଓ"))) + ("@O" (("ୋ"))) + ("O" (("ଓ"))) + ("@oo" (("ୂ"))) + ("oo" (("ଊ") ("ଓ"))) + ("@ou" (("ୌ"))) + ("ou" (("ଔ"))) + ("p^" (("ପ୍"))) + ("p" (("ପ୍") ("ପ୍ପ୍") ("ପି"))) + ("P^" (("ପ୍"))) + ("P" (("ପ୍") ("ପ୍ପ୍") ("ପି"))) + ("pa" (("ପ"))) + ("pA" (("ପା"))) + ("Pa" (("ପ") ("ପ") ("ପ"))) + ("PA" (("ପା"))) + ("paa" (("ପା"))) + ("Paa" (("ପା"))) + ("pae" (("ପେ"))) + ("Pae" (("ପେ"))) + ("paH" (("ପଃ"))) + ("PaH" (("ପଃ"))) + ("pai" (("ପୈ") ("ପଯ୍") ("ପାଯ୍"))) + ("Pai" (("ପୈ") ("ପଯ୍") ("ପାଯ୍"))) + ("paM" (("ପଂ"))) + ("PaM" (("ପଂ"))) + ("pau" (("ପୗ") ("ପୌ"))) + ("Pau" (("ପୗ") ("ପୌ"))) + ("pe" (("ପେ") ("ପିେ"))) + ("pE" (("ପେ"))) + ("Pe" (("ପେ") ("ପିେ"))) + ("PE" (("ପେ"))) + ("pee" (("ପୀ") ("ପେ"))) + ("Pee" (("ପୀ") ("ପୀ") ("ପୀ") ("ପେ"))) + ("pei" (("ପଯ୍") ("ପୈ"))) + ("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" (("ପୀ"))) + ("Pi" (("ପି") ("ପି") ("ପୈ") ("ପ୍ପି") ("ପି") )) + ("PI" (("ପୀ"))) + ("pii" (("ପୀ"))) + ("Pii" (("ପୀ"))) + ("po" (("ପୋ"))) + ("pO" (("ପୋ"))) + ("Po" (("ପୋ"))) + ("PO" (("ପୋ"))) + ("poo" (("ପୂ") ("ପୋ"))) + ("Poo" (("ପୂ") ("ପୂ") ("ପୋ") ("ପୂ"))) + ("pou" (("ପୌ"))) + ("Pou" (("ପୌ"))) + ("pR" (("ପୃ"))) + ("PR" (("ପୃ"))) + ("pu" (("ପୁ"))) + ("pU" (("ପୂ"))) + ("Pu" (("ପୁ") ("ପୁ") ("ପୁ"))) + ("PU" (("ପୂ"))) + ("puu" (("ପୂ"))) + ("Puu" (("ପୂ"))) + ("q" (("କ୍ଯୁ"))) + ("Q" (("କ୍ଯୂ"))) + ("r^^" (("ୠ"))) + ("r^" (("ଋ"))) + ("r" (("ର୍") ("ଆର୍"))) + ("@R" (("ୃ"))) + ("R^^" (("ୠ"))) + ("ra" (("ର"))) + ("rA" (("ରା"))) + ("raa" (("ରା"))) + ("rae" (("ରେ"))) + ("raH" (("ରଃ"))) + ("rai" (("ରୈ") ("ରାଯ୍"))) + ("raM" (("ରଂ"))) + ("rau" (("ରୗ"))) + ("re" (("ରେ"))) + ("rE" (("ରେ"))) + ("ree" (("ରୀ"))) + ("rei" (("ରୈ") ("ରଯ୍"))) + ("ri" (("ରି") ("ରୈ") ("ୈ"))) + ("rI" (("ରୀ"))) + ("rii" (("ରୀ"))) + ("ro" (("ରୋ") ("ରୋ"))) + ("rO" (("ରୋ"))) + ("roo" (("ରୂ"))) + ("rou" (("ରୌ"))) + ("rr" (("ଋ"))) + ("rR" (("ରୃ"))) + ("RR" (("ଋ"))) + ("ru" (("ରୁ"))) + ("rU" (("ରୂ"))) + ("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" (("ଷ୍"))) + ("sha" (("ଷ"))) + ("shA" (("ଷା"))) + ("shaa" (("ଷା"))) + ("shae" (("ଷେ"))) + ("shaH" (("ଷଃ"))) + ("shai" (("ଷୈ"))) + ("shaM" (("ଷଂ"))) + ("shau" (("ଷୗ") ("ଷୌ"))) + ("she" (("ଷେ") ("ଷିେ"))) + ("shE" (("ଷେ"))) + ("shee" (("ଷୀ") ("ଷେ"))) + ("shei" (("ଷୈ"))) + ("shi" (("ଷି"))) + ("shI" (("ଷୀ"))) + ("shii" (("ଷୀ"))) + ("sho" (("ଷୋ") ("ଷୋ"))) + ("shO" (("ଷୋ"))) + ("shoo" (("ଷୂ"))) + ("shou" (("ଷୌ"))) + ("shR" (("ଷୃ"))) + ("shu" (("ଷୁ"))) + ("shU" (("ଷୂ"))) + ("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" (("ଠୃ"))) + ("tu" (("ଟୁ") ("ତୁ") ("୍ୁ") ("ଟ୍ଟୁ"))) + ("tU" (("ଟୂ") ("୍ୂ"))) + ("Tu" (("ଠୁ") ("ଟୁ") ("ତୁ"))) + ("TU" (("ଠୂ"))) + ("tuu" (("ଟୂ") ("ତୂ") ("୍ୂ"))) + ("Tuu" (("ଠୂ"))) + ("@u" (("ୁ"))) + ("u" (("ଉ") ("ଊ") ("ଯୁ"))) + ("@U" (("ୂ"))) + ("U" (("ଊ"))) + ("@uu" (("ୂ"))) + ("uu" (("ଊ"))) + ("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" (("ଵ୍") ("ଵ୍ଵ୍") ("ଡବ୍ଲ୍ଯୂ"))) + ("W^" (("ଵ୍"))) + ("W" (("ଵ୍") ("ଵ୍ଵ୍") ("ଡବ୍ଲ୍ଯୂ"))) + ("wa" (("ଵ"))) + ("wA" (("ଵା"))) + ("Wa" (("ଵ"))) + ("WA" (("ଵା"))) + ("waa" (("ଵା"))) + ("Waa" (("ଵା"))) + ("wae" (("ଵେ"))) + ("Wae" (("ଵେ"))) + ("waH" (("ଵଃ"))) + ("WaH" (("ଵଃ"))) + ("wai" (("ଵୈ"))) + ("Wai" (("ଵୈ"))) + ("waM" (("ଵଂ"))) + ("WaM" (("ଵଂ"))) + ("wau" (("ଵୗ"))) + ("Wau" (("ଵୗ"))) + ("we" (("ଵେ"))) + ("wE" (("ଵେ"))) + ("We" (("ଵେ"))) + ("WE" (("ଵେ"))) + ("wee" (("ଵୀ"))) + ("Wee" (("ଵୀ"))) + ("wei" (("ଵୈ"))) + ("Wei" (("ଵୈ"))) + ("wi" (("ଵି"))) + ("wI" (("ଵୀ"))) + ("Wi" (("ଵି"))) + ("WI" (("ଵୀ"))) + ("wii" (("ଵୀ"))) + ("Wii" (("ଵୀ"))) + ("wo" (("ଵୋ"))) + ("wO" (("ଵୋ"))) + ("Wo" (("ଵୋ"))) + ("WO" (("ଵୋ"))) + ("woo" (("ଵୂ"))) + ("Woo" (("ଵୂ"))) + ("wou" (("ଵୌ"))) + ("Wou" (("ଵୌ"))) + ("wR" (("ଵୃ"))) + ("WR" (("ଵୃ"))) + ("wu" (("ଵୁ"))) + ("wU" (("ଵୂ"))) + ("Wu" (("ଵୁ"))) + ("WU" (("ଵୂ"))) + ("wuu" (("ଵୂ"))) + ("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" (("ଶ୍") ("ସ୍") ("ଇସଡ୍"))) + ("Z" (("ଶ୍") ("ସ୍") ("ଇସଡ୍"))) + ("za" (("ଶ") ("ସ"))) + ("zA" (("ଶା"))) + ("zaa" (("ଶା") ("ସା"))) + ("zaH" (("ଶଃ"))) + ("zai" (("ଶୈ"))) + ("zaM" (("ଶଂ"))) + ("zau" (("ଶୗ"))) + ("ze" (("ଶେ"))) + ("zE" (("ଶେ"))) + ("zee" (("ଶୀ") ("ସୀ"))) + ("zei" (("ଶୈ"))) + ("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: + |