diff options
Diffstat (limited to 'input-methods/m17n/swanalekha/pa-swanalekha.mim')
| -rwxr-xr-x | input-methods/m17n/swanalekha/pa-swanalekha.mim | 1334 |
1 files changed, 1334 insertions, 0 deletions
diff --git a/input-methods/m17n/swanalekha/pa-swanalekha.mim b/input-methods/m17n/swanalekha/pa-swanalekha.mim new file mode 100755 index 0000000..dc71b15 --- /dev/null +++ b/input-methods/m17n/swanalekha/pa-swanalekha.mim @@ -0,0 +1,1334 @@ +(input-method pa swanalekha) + +(description "Swanalekha Panjabi input method") + + +(title "Panjabi") +(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" (("ਆ"))) + ("@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" (("ਇ") ("ਈ") ("ਐ"))) + ("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" (("ਖ"))) + ("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" (("ਮ੍") )) + ("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" (("ਙਾ"))) + ("ngai" (("ਙੈ"))) + ("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" (("ਔ"))) + ("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" (("ਪਿ"))) + ("Pi" (("ਪਿ") )) + ("pii" (("ਪਿ"))) + ("po" (("ਪੋ"))) + ("pO" (("ਪੌ"))) + ("poo" (("ਪੂ") ("ਪੌ"))) + ("Poo" (("ਪੂ"))) + ("pou" (("ਪੌ"))) + ("pR" (("ਪ"))) + ("pu" (("ਪੁ"))) + ("pU" (("ਪੂ"))) + ("Pu" (("ਪੁ"))) + ("puu" (("ਪੂ"))) + ("q" (("ਕ੍ਯੁ"))) + ("Q" (("ਕ੍ਯੂ"))) + ("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" (("ਰ"))) + ("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" (("ਾ"))) + ("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" (("ੇ"))) + ("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" (("ਊ"))) + ("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" (("ਵ੍") ("ਵ੍ਵ੍") ("ਡਬ੍ਲ੍ਯੂ"))) + ("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" (("ਾ"))) + ("zhaa" (("ਾ"))) + ("zhae" (("ੈ"))) + ("zhaH" (("ਃ"))) + ("zhai" (("ੈ"))) + ("zhaM" (("ਁ"))) + ("zhau" (("ੌ") ("ੇ"))) + ("zhe" (("ੇ"))) + ("zhE" (("ੈ"))) + ("zhee" (("ੀ"))) + ("zhei" (("ੈ"))) + ("zhi" (("ਿ"))) + ("zhI" (("ੀ"))) + ("zhii" (("ੀ"))) + ("zho" (("ੋ"))) + ("zhO" (("ੌ"))) + ("zhoo" (("ੂ"))) + ("zhou" (("ੇ"))) + ("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: |