diff options
Diffstat (limited to 'input-methods/m17n/swanalekha')
27 files changed, 15779 insertions, 156 deletions
diff --git a/input-methods/m17n/swanalekha/COPYING b/input-methods/m17n/swanalekha/COPYING new file mode 100644 index 0000000..2cff703 --- /dev/null +++ b/input-methods/m17n/swanalekha/COPYING @@ -0,0 +1,343 @@ +The swanalekha m17n source files are licensed under GNU General Public License version 2 or later +Copyright: Santhosh Thottingal <santhosh.thottingal@gmail.com>, 2008 + + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/input-methods/m17n/swanalekha/COPYRIGHT b/input-methods/m17n/swanalekha/COPYRIGHT new file mode 100755 index 0000000..2e559fa --- /dev/null +++ b/input-methods/m17n/swanalekha/COPYRIGHT @@ -0,0 +1,22 @@ + +Copyright 2001 by Simputer Trust + + +This software ( all code and data under this directory, including the +database ) is supplied under the terms of the GNU General Public +License version 2 or later. + +The full text of the license can be found at : + + http://www.gnu.org/copyleft/gpl.html + + +As a matter of courtesy, the authors request to be informed about uses +this software has found, about bugs in this software, and about any +improvements that may be of general interest. + + +Ramesh Hariharan +ramesh@csa.iisc.ernet.in + + diff --git a/input-methods/m17n/swanalekha/ChangeLog b/input-methods/m17n/swanalekha/ChangeLog new file mode 100755 index 0000000..caa62f1 --- /dev/null +++ b/input-methods/m17n/swanalekha/ChangeLog @@ -0,0 +1,15 @@ +version 0.04 : + * 26.01.2009 Fixed a minor bug in ngU, ngoo pattern in malayalam +version 0.03 : + * Fixed Panjabi table + * Fixed Oriya mapping problems + * Added Sinhala, Assami, Tamil, Marathi languages + * New icons for each languages + * sorted the mappings for locating the english letter sequence easily + +version 0.02 : + * Added tables for Telugu, Kannada, Oriya, Bengali, Gujarati, Panjabi (Thanks to Parag Namade for creating .mim files from scim mapping tables) + +version 0.01 : + * Malayalam version + diff --git a/input-methods/m17n/swanalekha/README b/input-methods/m17n/swanalekha/README new file mode 100755 index 0000000..d2e5ffc --- /dev/null +++ b/input-methods/m17n/swanalekha/README @@ -0,0 +1,31 @@ +Swanalekha Transliteration based Input Method for Indic Languages +================================================================= + +Features +--------- +* Transliteration based input method for gnu/linux systems +* Flexible transliteration scheme with the help of context menus showing candidates for the typed english letter sequence +* Since it is not following strict transliteration schema, it is easy to learn + +TODO +---- +Only Malayalam is complete as of now. Other keymaps need to be optimized for those languages + + +Required Packages +----------------- +m17n-db, m17n-contrib , scim-m17n + + +Installation +------------ +Run the install.sh with root permission or using sudo + +License +------------ +All keymaps are licensed under GPLv3 or later version + +Authors +----------- +* Santhosh Thottingal <santhosh.thottingal at gmail.com> +* Parag Namade <pnamade at redhat.com diff --git a/input-methods/m17n/swanalekha/as-swanalekha.mim b/input-methods/m17n/swanalekha/as-swanalekha.mim new file mode 100755 index 0000000..05c2b11 --- /dev/null +++ b/input-methods/m17n/swanalekha/as-swanalekha.mim @@ -0,0 +1,1340 @@ +(input-method as swanalekha) + +(description "Swanalekha Assamese input method") + + +(title "assamese") +(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_" (("র্"))) + ("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" (("ঊ"))) + ("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" (("া"))) + ("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: diff --git a/input-methods/m17n/swanalekha/as-swanalekha.png b/input-methods/m17n/swanalekha/as-swanalekha.png Binary files differnew file mode 100755 index 0000000..96c1012 --- /dev/null +++ b/input-methods/m17n/swanalekha/as-swanalekha.png diff --git a/input-methods/m17n/swanalekha/bn-swanalekha.mim b/input-methods/m17n/swanalekha/bn-swanalekha.mim new file mode 100755 index 0000000..8a02980 --- /dev/null +++ b/input-methods/m17n/swanalekha/bn-swanalekha.mim @@ -0,0 +1,1342 @@ +(input-method bn swanalekha) + +(description "Swanalekha Bengali input method") + + +(title "bengali") +(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_" (("র্"))) + ("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" (("ঊ"))) + ("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" (("া"))) + ("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: diff --git a/input-methods/m17n/swanalekha/bn-swanalekha.png b/input-methods/m17n/swanalekha/bn-swanalekha.png Binary files differnew file mode 100755 index 0000000..b7ff050 --- /dev/null +++ b/input-methods/m17n/swanalekha/bn-swanalekha.png diff --git a/input-methods/m17n/swanalekha/gu-swanalekha.mim b/input-methods/m17n/swanalekha/gu-swanalekha.mim new file mode 100755 index 0000000..ab6bf0b --- /dev/null +++ b/input-methods/m17n/swanalekha/gu-swanalekha.mim @@ -0,0 +1,1341 @@ +(input-method gu swanalekha) + +(description "Swanalekha Gujarati input method") + + +(title "gujarati") +(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 + ("~" ((""))) + ("_" ((""))) + ("aa" (("આ"))) + ("@aa" (("ા"))) + ("aH" (("અઃ"))) + ("@ah" (("ઃ"))) + ("@aH" (("ઃ"))) + ("ai" (("ઐ"))) + ("aM" (("અઁ"))) + ("au" (("ઔ"))) + ("a" (("અ") ("આ") ("એ"))) + ("A" (("આ") ("એ"))) + ("baa" (("બા"))) + ("Baa" (("ભા") ("બા"))) + ("bae" (("બૈ"))) + ("baH" (("બઃ"))) + ("BaH" (("ભઃ"))) + ("bai" (("બૈ") ("બાય્"))) + ("Bai" (("ભૈ"))) + ("baM" (("બઁ"))) + ("BaM" (("ભઁ"))) + ("bau" (("બૌ") ("બૌ") ("ભૌ"))) + ("Bau" (("ભૌ") ("ભે"))) + ("ba" (("બ"))) + ("bA" (("બા"))) + ("Ba" (("ભ") ("બ") ("બા"))) + ("BA" (("ભા") ("બિ.એ."))) + ("bee" (("બી"))) + ("Bee" (("ભી"))) + ("bei" (("બૈ"))) + ("Bei" (("ભૈ"))) + ("be" (("બે"))) + ("bE" (("બૈ"))) + ("Be" (("ભે"))) + ("BE" (("ભૈ"))) + ("bhaa" (("ભા"))) + ("bhae" (("ભૈ"))) + ("bhaH" (("ભઃ"))) + ("bhai" (("ભૈ") ("ભાય્"))) + ("bhaM" (("ભઁ"))) + ("bhau" (("ભૌ") ("ભે"))) + ("bha" (("ભ"))) + ("bhA" (("ભા"))) + ("bhee" (("ભી"))) + ("bhei" (("ભૈ"))) + ("bhe" (("ભે"))) + ("bhE" (("ભૈ"))) + ("bhii" (("ભી"))) + ("bhi" (("ભિ"))) + ("bhI" (("ભિ"))) + ("bhoo" (("ભૂ"))) + ("bhou" (("ભે"))) + ("bho" (("ભો"))) + ("bhO" (("ભૌ"))) + ("bhR" (("ભૃ"))) + ("bhuu" (("ભૂ"))) + ("bhu" (("ભુ"))) + ("bhU" (("ભૂ"))) + ("bh^" (("ભ્"))) + ("bh" (("ભ્"))) + ("bii" (("બી"))) + ("Bii" (("ભી"))) + ("bi" (("બિ") ("બૈ"))) + ("bI" (("બી"))) + ("Bi" (("ભિ") ("બૈ"))) + ("BI" (("ભી"))) + ("boo" (("બૂ") ("બૌ"))) + ("Boo" (("ભૂ"))) + ("bou" (("બૌ"))) + ("Bou" (("ભે"))) + ("bo" (("બો"))) + ("bO" (("બૌ"))) + ("Bo" (("ભો") ("બૌ"))) + ("BO" (("ભૌ"))) + ("bR" (("બૃ"))) + ("BR" (("ભૃ"))) + ("buu" (("બૂ"))) + ("Buu" (("ભૂ"))) + ("bu" (("બુ"))) + ("bU" (("બૂ"))) + ("Bu" (("ભુ") ("બુ"))) + ("BU" (("ભૂ"))) + ("b^" (("બ્"))) + ("b" (("બ્") ("બ્બ્") ("બિ"))) + ("B^" (("ભ્"))) + ("B" (("ભ્") ("બ્") ("બિ"))) + ("caa" (("કા"))) + ("cae" (("કૈ"))) + ("cai" (("કૈ"))) + ("cau" (("કૌ"))) + ("ca" (("ક") ("કા") ("કૈ"))) + ("cA" (("કા"))) + ("cee" (("કિ"))) + ("cei" (("કૈ"))) + ("ce" (("કે") ("સ્"))) + ("cE" (("કૈ"))) + ("chaa" (("ચા"))) + ("Chaa" (("છા"))) + ("chae" (("ચૈ"))) + ("Chae" (("છૈ"))) + ("chaH" (("ચઃ"))) + ("ChaH" (("છઃ"))) + ("chai" (("ચૈ") ("ચાય્"))) + ("Chai" (("છૈ"))) + ("chaM" (("ચઁ"))) + ("ChaM" (("છઁ"))) + ("chau" (("ચૌ"))) + ("Chau" (("છૌ") ("છે"))) + ("cha" (("ચ") ("ચ્ચ") ("ચ્છ"))) + ("chA" (("ચા"))) + ("Cha" (("છ") ("ચ") ("ચ્ચ"))) + ("ChA" (("છા"))) + ("chee" (("ચી") ("ચ્ચી"))) + ("Chee" (("છી"))) + ("chei" (("ચૈ"))) + ("Chei" (("છૈ"))) + ("che" (("ચે") ("ચ્ચે"))) + ("chE" (("ચૈ"))) + ("Che" (("છે"))) + ("ChE" (("છૈ"))) + ("chhaa" (("છા"))) + ("chhae" (("છૈ"))) + ("chhaH" (("છઃ"))) + ("chhai" (("છૈ"))) + ("chhaM" (("છઁ"))) + ("chhau" (("છૌ") ("છે"))) + ("chha" (("છ") ("ચ્ચ"))) + ("chhA" (("છા"))) + ("chhee" (("છી"))) + ("chhei" (("છૈ"))) + ("chhe" (("છે"))) + ("chhE" (("છૈ"))) + ("chhii" (("છી"))) + ("chhI" (("છિ"))) + ("chhi" (("છી"))) + ("chhoo" (("છૂ"))) + ("chhou" (("છે"))) + ("chho" (("છો"))) + ("chhO" (("છૌ"))) + ("chhR" (("છૃ"))) + ("chhuu" (("છૂ"))) + ("chhu" (("છુ"))) + ("chhU" (("છૂ"))) + ("chh^" (("છ્"))) + ("chh" (("છ્"))) + ("chii" (("ચી"))) + ("Chii" (("છી"))) + ("chi" (("ચિ") ("ચ્ચિ") ("ચૈ"))) + ("chI" (("ચી"))) + ("Chi" (("છિ") ("ચિ"))) + ("ChI" (("છી"))) + ("choo" (("ચૂ") ("ચ્ચૂ") ("ચૌ"))) + ("Choo" (("છૂ"))) + ("chou" (("ચે"))) + ("Chou" (("છે"))) + ("cho" (("ચો") ("ચૌ"))) + ("chO" (("ચૌ"))) + ("Cho" (("છો"))) + ("ChO" (("છૌ"))) + ("chR" (("ચૃ"))) + ("ChR" (("છૃ"))) + ("chuu" (("ચૂ") ("ચ્ચૂ"))) + ("Chuu" (("છૂ"))) + ("chu" (("ચુ") ("ચ્યુ"))) + ("chU" (("ચૂ"))) + ("Chu" (("છુ") ("ચુ"))) + ("ChU" (("છૂ"))) + ("ch^" (("ચ્"))) + ("ch" (("ચ્") ("ચ્ચ્") ("ક્ક્"))) + ("Ch^" (("છ્"))) + ("Ch" (("છ્"))) + ("ci" (("કિ") ("સિ") ("સૈ"))) + ("cI" (("કી"))) + ("cka" (("ક"))) + ("ck" (("ક્ક્"))) + ("coo" (("કૂ"))) + ("cou" (("કે"))) + ("co" (("કો"))) + ("cO" (("કો"))) + ("cR" (("કૃ"))) + ("cuu" (("કૂ"))) + ("cu" (("કુ"))) + ("cU" (("કૂ"))) + ("c" (("ક્") ("સિ"))) + ("C" (("સિ"))) + ("Daa" (("ડા"))) + ("daa" (("દા") ("ટા"))) + ("Dae" (("ડૈ"))) + ("dae" (("દૈ"))) + ("DaH" (("ડઃ"))) + ("daH" (("દઃ"))) + ("Dai" (("ડૈ"))) + ("dai" (("દૈ") ("ડાય્"))) + ("DaM" (("ડઁ"))) + ("daM" (("દઁ"))) + ("Dau" (("ડૌ") ("ડે"))) + ("dau" (("દૌ") ("દે"))) + ("Da" (("ડ") ("દ") ("ઠ"))) + ("DA" (("ડા"))) + ("da" (("દ") ("ટ") ("ડ"))) + ("dA" (("દા") ("ટા"))) + ("Dee" (("ડી"))) + ("dee" (("દી") ("ટી"))) + ("Dei" (("ડૈ"))) + ("dei" (("દૈ") ("ડૈય્"))) + ("De" (("ડે") ("ટે"))) + ("DE" (("ડૈ"))) + ("de" (("દે") ("ટે") ("તે"))) + ("dE" (("દૈ") ("તૈ"))) + ("Dhaa" (("ઢા"))) + ("dhaa" (("ધા"))) + ("Dhae" (("ઢૈ"))) + ("dhae" (("ધૈ"))) + ("DhaH" (("ઢઃ"))) + ("dhaH" (("ધઃ"))) + ("Dhai" (("ઢૈ"))) + ("dhai" (("ધૈ"))) + ("DhaM" (("ઢઁ"))) + ("dhaM" (("ધઁ"))) + ("Dhau" (("ઢૌ") ("ઢે"))) + ("dhau" (("ધૌ") ("ધે"))) + ("Dha" (("ઢ"))) + ("DhA" (("ઢા"))) + ("dha" (("ધ"))) + ("dhA" (("ધા"))) + ("Dhee" (("ઢી"))) + ("dhee" (("ધિ"))) + ("Dhei" (("ઢૈ"))) + ("dhei" (("ધૈ"))) + ("Dhe" (("ઢે"))) + ("DhE" (("ઢૈ"))) + ("dhe" (("ધે"))) + ("dhE" (("ધૈ"))) + ("Dhii" (("ઢી"))) + ("dhii" (("ધિ"))) + ("Dhi" (("ઢિ"))) + ("DhI" (("ઢી"))) + ("dhi" (("ધિ"))) + ("dhI" (("ધિ"))) + ("Dhoo" (("ઢૂ"))) + ("dhoo" (("ધૂ"))) + ("Dhou" (("ઢે"))) + ("dhou" (("ધે"))) + ("Dho" (("ઢો"))) + ("DhO" (("ઢૌ"))) + ("dho" (("ધો"))) + ("dhO" (("ધૌ"))) + ("DhR" (("ઢૃ"))) + ("dhR" (("ધૃ"))) + ("Dhuu" (("ઢૂ"))) + ("dhuu" (("ધૂ"))) + ("Dhu" (("ઢુ"))) + ("DhU" (("ઢૂ"))) + ("dhu" (("ધુ"))) + ("dhU" (("ધૂ"))) + ("Dh^" (("ઢ્"))) + ("Dh" (("ઢ્"))) + ("dh^" (("ધ્"))) + ("dh" (("ધ્"))) + ("Dii" (("ડી"))) + ("dii" (("દી") ("ટી"))) + ("Di" (("ડિ"))) + ("DI" (("ડી"))) + ("dI" (("દિ") ("ટિ"))) + ("di" (("દિ") ("ટિ") ("ધિ") ("થિ") ("ડૈ"))) + ("Doo" (("ડૂ"))) + ("doo" (("દૂ"))) + ("Dou" (("ડે"))) + ("dou" (("દે"))) + ("Do" (("ડો"))) + ("DO" (("ડૌ"))) + ("do" (("દો"))) + ("dO" (("દૌ"))) + ("DR" (("ડૃ"))) + ("dR" (("દૃ"))) + ("Duu" (("ડૂ"))) + ("duu" (("દૂ"))) + ("Du" (("ડુ") ("દુ"))) + ("DU" (("ડૂ"))) + ("du" (("દુ") ("ટુ") ("દુઃ"))) + ("dU" (("દૂ"))) + ("D^" (("ડ્"))) + ("D" (("ડ્") ("દ્") ("ડિ"))) + ("d^" (("દ્"))) + ("d" (("દ્") ("ટ્") ("ડિ") ("દ્દ્"))) + ("ee" (("ઈ"))) + ("ei" (("ઐ"))) + ("E" (("ઇ"))) + ("e" (("એ") ("ઇ"))) + ("faa" (("ફા"))) + ("faH" (("ફઃ"))) + ("fai" (("ફૈ"))) + ("faM" (("ફઁ"))) + ("fau" (("ફૌ") ("ફે"))) + ("fa" (("ફ"))) + ("fA" (("ફા"))) + ("fee" (("ફી"))) + ("fei" (("ફૈ"))) + ("fe" (("ફે"))) + ("fE" (("ફૈ"))) + ("fii" (("ફી"))) + ("fi" (("ફિ"))) + ("fI" (("ફી"))) + ("foo" (("ફૂ"))) + ("fou" (("ફે"))) + ("fo" (("ફો"))) + ("fO" (("ફૌ"))) + ("fR" (("ફૃ"))) + ("fuu" (("ફૂ"))) + ("fu" (("ફુ"))) + ("fU" (("ફૂ"))) + ("f^" (("ફ્"))) + ("f" (("ફ્") ("એફ્"))) + ("gaa" (("ગા"))) + ("Gaa" (("ઘા") ("ગ્ગા"))) + ("gae" (("ગૈ"))) + ("Gae" (("ઘૈ") ("ગ્ગૈ"))) + ("gaH" (("ગઃ"))) + ("GaH" (("ઘઃ"))) + ("gai" (("ગૈ"))) + ("Gai" (("ઘૈ") ("ગય્") ("ગેય્") ("ગ્ગૈ"))) + ("gaM" (("ગઁ"))) + ("GaM" (("ઘઁ"))) + ("gau" (("ગૌ") ("ગે"))) + ("Gau" (("ઘૌ") ("ગૌ") ("ઘે"))) + ("ga" (("ગ") ("જ") ("ક") ("ખ"))) + ("gA" (("ગા"))) + ("Ga" (("ઘ") ("ગ") ("ગ્ગ") ("જ"))) + ("GA" (("ઘા") ("ગ્ગા"))) + ("gee" (("ગી"))) + ("Gee" (("ઘિ") ("ગ્ગિ"))) + ("gei" (("ગૈ"))) + ("Gei" (("ઘૈ") ("ગ્ગૈ"))) + ("ge" (("ગે"))) + ("gE" (("ગૈ"))) + ("Ge" (("ઘે") ("ગે") ("ગ્ગે") ("જે"))) + ("GE" (("ઘૈ") ("ગ્ગૈ"))) + ("ghaa" (("ઘા"))) + ("ghae" (("ઘૈ"))) + ("ghaH" (("ઘઃ"))) + ("ghai" (("ઘૈ"))) + ("ghaM" (("ઘઁ"))) + ("ghau" (("ઘૌ"))) + ("gha" (("ઘ") ("ખ"))) + ("ghA" (("ઘા"))) + ("ghee" (("ઘિ"))) + ("ghei" (("ઘૈ"))) + ("ghe" (("ઘે"))) + ("ghE" (("ઘૈ"))) + ("ghii" (("ઘિ"))) + ("ghi" (("ઘિ"))) + ("ghI" (("ઘિ"))) + ("ghoo" (("ઘૂ"))) + ("ghou" (("ઘે"))) + ("gho" (("ઘો"))) + ("ghO" (("ઘૌ"))) + ("ghR" (("ઘૃ"))) + ("ghuu" (("ઘૂ"))) + ("ghu" (("ઘુ"))) + ("ghU" (("ઘૂ"))) + ("gh^" (("ઘ્"))) + ("gh" (("ઘ્"))) + ("gii" (("ગી"))) + ("Gii" (("ઘી") ("ગ્ગી"))) + ("gi" (("ગિ") ("કિ") ("જિ"))) + ("gI" (("ગી"))) + ("GI" (("ઘિ") ("ગ્ગિ") ("ગ્ગિ"))) + ("Gi" (("ઘિ") ("ગ્ગી"))) + ("goo" (("ગૂ") ("ગૌ"))) + ("Goo" (("ઘૂ") ("ગ્ગૂ") ("ઘૌ") ("ગ્ગૌ"))) + ("gou" (("ગે"))) + ("Gou" (("ઘે"))) + ("go" (("ગો") ("ગૌ"))) + ("gO" (("ગૌ"))) + ("Go" (("ઘો") ("ગૌ") ("ગો") ("ગ્ગો"))) + ("GO" (("ઘૌ"))) + ("gR" (("ગૃ"))) + ("GR" (("ઘૃ") ("ગ્ગૃ"))) + ("guu" (("ગૂ"))) + ("Guu" (("ઘૂ") ("ગ્ગૂ"))) + ("gu" (("ગુ"))) + ("gU" (("ગૂ"))) + ("Gu" (("ઘુ") ("ગુ") ("ગ્ગુ"))) + ("GU" (("ઘૂ") ("ગ્ગૂ"))) + ("g^" (("ગ્"))) + ("g" (("ગ્") ("જિ"))) + ("G^" (("ઘ્"))) + ("G" (("ઘ્") ("જિ") ("ગ્ગિ"))) + ("haa" (("હા"))) + ("haH" (("હઃ"))) + ("hai" (("હૈ") ("હાય્"))) + ("haM" (("હઁ"))) + ("hau" (("હૌ"))) + ("ha" (("હ") ("હા"))) + ("hA" (("હા"))) + ("hee" (("હી"))) + ("hei" (("હૈ") ("હૈય્"))) + ("he" (("હે") ("હિ"))) + ("hE" (("હૈ"))) + ("hii" (("હી"))) + ("hi" (("હિ") ("હાય્"))) + ("hI" (("હી"))) + ("hoo" (("હૂ"))) + ("hou" (("હૌ"))) + ("ho" (("હો") ("હૌ"))) + ("hO" (("હૌ"))) + ("hR" (("હૃ"))) + ("huu" (("હૂ"))) + ("hu" (("હુ"))) + ("hU" (("હૂ"))) + ("H" (("એચ્ચ્"))) + ("h^" (("હ્"))) + ("h" (("હ્") ("એચ્") ("એચ્ચ્"))) + ("ii" (("ઈ"))) + ("@ii" (("ી"))) + ("i" (("ઇ") ("ઈ") ("ઐ"))) + ("I" (("ઈ") ("ઐ"))) + ("jaa" (("જા"))) + ("Jaa" (("ઝા"))) + ("jae" (("જૈ"))) + ("Jae" (("ઝૈ"))) + ("jaH" (("જઃ"))) + ("JaH" (("ઝઃ"))) + ("jai" (("જૈ") ("જય્"))) + ("Jai" (("ઝૈ") ("જય્"))) + ("jaM" (("જઁ"))) + ("JaM" (("ઝઁ"))) + ("jau" (("જૌ") ("જે"))) + ("Jau" (("ઝૌ") ("ઝે"))) + ("ja" (("જ") ("જે"))) + ("jA" (("જા"))) + ("Ja" (("ઝ") ("જ") ("જે"))) + ("JA" (("ઝા"))) + ("jee" (("જી"))) + ("Jee" (("ઝી") ("જી"))) + ("jei" (("જૈ"))) + ("Jei" (("ઝૈ"))) + ("je" (("જે") ("જિ"))) + ("jE" (("જૈ"))) + ("Je" (("ઝે"))) + ("JE" (("ઝૈ"))) + ("jhaa" (("ઝા"))) + ("jhae" (("ઝૈ"))) + ("jhaH" (("ઝઃ"))) + ("jhai" (("ઝૈ"))) + ("jhaM" (("ઝઁ"))) + ("jhau" (("ઝૌ") ("ઝે"))) + ("jha" (("ઝ"))) + ("jhA" (("ઝા"))) + ("jhee" (("ઝિ"))) + ("jhei" (("ઝૈ"))) + ("jhe" (("ઝે"))) + ("jhE" (("ઝૈ"))) + ("jhii" (("ઝિ"))) + ("jhi" (("ઝિ"))) + ("jhI" (("ઝિ"))) + ("jhoo" (("ઝૂ") ("ઝૌ"))) + ("jhou" (("ઝે"))) + ("jho" (("ઝો"))) + ("jhO" (("ઝૌ"))) + ("jhR" (("ઝૃ"))) + ("jhuu" (("ઝૂ"))) + ("jhu" (("ઝુ"))) + ("jhU" (("ઝૂ"))) + ("jh^" (("ઝ્"))) + ("jh" (("ઝ્"))) + ("jii" (("જી"))) + ("Jii" (("ઝી"))) + ("jI" (("જિ"))) + ("ji" (("જિ") ("જૈ"))) + ("Ji" (("ઝિ") ("જિ") ("જૈ"))) + ("JI" (("ઝી"))) + ("joo" (("જૂ"))) + ("Joo" (("ઝૂ") ("જૂ") ("ઝૌ"))) + ("jou" (("જે"))) + ("Jou" (("ઝે"))) + ("jo" (("જો"))) + ("jO" (("જૌ"))) + ("Jo" (("ઝો") ("જૌ") ("જો"))) + ("JO" (("ઝૌ"))) + ("jR" (("જૃ"))) + ("JR" (("ઝૃ") ("જે.આર્"))) + ("juu" (("જૂ"))) + ("Juu" (("ઝૂ") ("જૂ"))) + ("ju" (("જુ"))) + ("jU" (("જૂ"))) + ("Ju" (("ઝુ") ("જુ"))) + ("JU" (("ઝૂ") ("જે.યુ."))) + ("j^" (("જ્"))) + ("j" (("જ્") ("જે"))) + ("J" (("ઝ્") ("જે"))) + ("kaa" (("કા") ("ગા"))) + ("Kaa" (("ખા"))) + ("kae" (("કૈ"))) + ("Kae" (("ખૈ"))) + ("kaH" (("કઃ"))) + ("KaH" (("ખઃ"))) + ("kai" (("કૈ") ("કય્"))) + ("Kai" (("ખૈ"))) + ("kaM" (("કઁ"))) + ("KaM" (("ખઁ"))) + ("kau" (("કૌ") ("કે"))) + ("Kau" (("ખૌ"))) + ("ka" (("ક") ("ગ") ("ખ") ("ઘ"))) + ("kA" (("કા"))) + ("Ka" (("ખ") ("ક") ("ક્ક"))) + ("KA" (("ખા"))) + ("kee" (("કી"))) + ("Kee" (("ખિ") ("કિ"))) + ("kei" (("કૈ") ("કેય્"))) + ("Kei" (("ખૈ"))) + ("ke" (("કે"))) + ("kE" (("કૈ"))) + ("Ke" (("ખે") ("કે"))) + ("KE" (("ખૈ"))) + ("khaa" (("ખા"))) + ("khae" (("ખૈ"))) + ("khaH" (("ખઃ"))) + ("khai" (("ખૈ"))) + ("khaM" (("ખઁ"))) + ("khau" (("ખૌ") ("ખે"))) + ("kha" (("ખ") ("ક્ક") ("ઘ"))) + ("khA" (("ખા"))) + ("khee" (("ખિ"))) + ("khei" (("ખૈ"))) + ("khe" (("ખે"))) + ("khE" (("ખૈ"))) + ("khii" (("ખિ"))) + ("khI" (("ખિ"))) + ("khi" (("ખિ") ("ક્કિ"))) + ("khoo" (("ખૂ"))) + ("khou" (("ખે"))) + ("kho" (("ખો"))) + ("khO" (("ખૌ"))) + ("khR" (("ખૃ"))) + ("khuu" (("ખૂ"))) + ("khu" (("ખુ") ("ઘુ"))) + ("khU" (("ખૂ"))) + ("kh^" (("ખ્"))) + ("kh" (("ખ્") ("ઘ્"))) + ("Kii" (("ખિ"))) + ("ki" (("કિ") ("ગિ") ("ઘિ") ("ખિ") ("કૈ"))) + ("KI" (("ખ"))) + ("Ki" (("ખિ") ("કિ"))) + ("koo" (("કૂ") ("ક"))) + ("Koo" (("ખૂ") ("કૂ") ("કૌ"))) + ("kou" (("કે"))) + ("Kou" (("ખે"))) + ("ko" (("કો"))) + ("kO" (("કો"))) + ("Ko" (("ખો") ("કો") ("કૌ"))) + ("KO" (("ખૌ"))) + ("kR" (("કૃ"))) + ("KR" (("ખૃ"))) + ("kuu" (("કૂ"))) + ("Kuu" (("ખૂ") ("કૂ"))) + ("ku" (("કુ") ("કૂ"))) + ("kU" (("કૂ"))) + ("Ku" (("ખુ") ("કુ"))) + ("KU" (("ખૂ"))) + ("k^" (("ક્"))) + ("k" (("ક્") ("ક્ક્") ("કે"))) + ("K^" (("ખ્"))) + ("K" (("ખ્") ("કે"))) + ("laa" (("લા") ("લા"))) + ("Laa" (("લા") ("લા"))) + ("lae" (("લૈ"))) + ("Lae" (("લૈ") ("લૈ"))) + ("laH" (("લઃ"))) + ("LaH" (("લઃ"))) + ("lai" (("લૈ"))) + ("Lai" (("લૈ"))) + ("laM" (("લઁ"))) + ("LaM" (("લઁ"))) + ("lau" (("લૌ"))) + ("Lau" (("લૌ") ("લૌ") ("લે"))) + ("la" (("લ") ("લ"))) + ("La" (("લ") ("લ"))) + ("lA" (("લા"))) + ("LA" (("લા"))) + ("lee" (("લી") ("લી"))) + ("Lee" (("લી") ("લી"))) + ("lei" (("લૈ"))) + ("Lei" (("લૈ"))) + ("le" (("લે") ("લે"))) + ("Le" (("લે") ("લે"))) + ("lE" (("લૈ"))) + ("LE" (("લૈ") ("લૈ"))) + ("lii" (("લી"))) + ("Lii" (("લી"))) + ("Li" (("લિ") ("લિ"))) + ("li" (("લિ") ("લિ") ("લૈ") ("લૈ"))) + ("lI" (("લી"))) + ("LI" (("લી"))) + ("Loo" (("લૂ") ("લૂ"))) + ("loo" (("લૂ") ("લૌ"))) + ("lou" (("લે"))) + ("Lou" (("લે"))) + ("lo" (("લો") ("લૌ"))) + ("Lo" (("લો") ("લૌ") ("લો"))) + ("lO" (("લૌ"))) + ("LO" (("લૌ"))) + ("lR" (("લૃ"))) + ("LR" (("લૃ"))) + ("luu" (("લૂ"))) + ("Luu" (("લૂ") ("લૂ"))) + ("lu" (("લુ") ("લુ"))) + ("Lu" (("લુ") ("લુ"))) + ("lU" (("લૂ"))) + ("LU" (("લૂ"))) + ("l^" (("લ્"))) + ("l~" (("લ્"))) + ("l_" (("લ્"))) + ("L^" (("લ્"))) + ("L~" (("લ્"))) + ("L_" (("લ્"))) + ("L" (("લ્") ("લ્") ("એલ્") ("લ્લ્"))) + ("l" (("લ્") ("લ્") ("લ્") ("એલ્"))) + ("maa" (("મા"))) + ("mae" (("મૈ"))) + ("maH" (("મઃ"))) + ("mai" (("મૈ") ("મય્"))) + ("maM" (("મઁ"))) + ("mau" (("મૌ") ("મે"))) + ("ma" (("મ") ("મ્મ"))) + ("mA" (("મા"))) + ("mee" (("મી"))) + ("mei" (("મેય્") ("મૈ"))) + ("me" (("મે"))) + ("mE" (("મૈ"))) + ("mii" (("મી"))) + ("mi" (("મિ"))) + ("mI" (("મિ"))) + ("moo" (("મૂ") ("મૌ"))) + ("mou" (("મે"))) + ("mo" (("મો") ("મૌ"))) + ("mO" (("મૌ"))) + ("mR" (("મૃ"))) + ("muu" (("મૂ"))) + ("mu" (("મુ"))) + ("mU" (("મૂ"))) + ("m^" (("મ્"))) + ("m" (("મ્") )) + ("m~" (("ઁ"))) + ("m_" (("ઁ"))) + ("Naa" (("ણા") ("ના"))) + ("naa" (("ના") ("ણા"))) + ("Nae" (("ણૈ"))) + ("nae" (("નૈ"))) + ("NaH" (("ણઃ"))) + ("naH" (("નઃ"))) + ("Nai" (("ણૈ"))) + ("nai" (("નૈ") ("નાય્"))) + ("NaM" (("ણઁ"))) + ("naM" (("નઁ"))) + ("Nau" (("ણૌ") ("ણે"))) + ("nau" (("નૌ") ("નૌ"))) + ("Na" (("ણ") ("ન") ("ના") ("ણ્ણ"))) + ("NA" (("ણા"))) + ("na" (("ન") ("ણ"))) + ("nA" (("ના"))) + ("Nee" (("ણી") ("ણૈ") ("નિ"))) + ("nee" (("ની"))) + ("Nei" (("ણૈ"))) + ("nei" (("નેય્") ("નૈ"))) + ("Ne" (("ણે"))) + ("NE" (("ણૈ"))) + ("ne" (("ને") ("ન્") ("ણ્"))) + ("nE" (("નૈ"))) + ("ngaa" (("ઙા"))) + ("ngai" (("ઙૈ"))) + ("ngaM" (("ઙઁ"))) + ("ngau" (("ઙૌ"))) + ("nga" (("ઙ") ("ઙ્ઙ"))) + ("ngA" (("ઙા"))) + ("ngee" (("ઙી"))) + ("ngei" (("ઙૈ"))) + ("nge" (("ઙે"))) + ("ngE" (("ઙૈ"))) + ("ngii" (("ઙી"))) + ("ngi" (("ઙિ"))) + ("ngoo" (("ઙૂ"))) + ("ngou" (("ઙે"))) + ("ngo" (("ઙો"))) + ("ngO" (("ઙૌ"))) + ("ngR" (("ઙૃ"))) + ("nguu" (("ઙૂ"))) + ("ngu" (("ઙુ"))) + ("ng^" (("ઙ્"))) + ("ng" (("ઙ્"))) + ("Nii" (("ણી"))) + ("nii" (("ની") ("ણી"))) + ("Ni" (("ણિ") ("ણ્ણિ"))) + ("NI" (("ણી"))) + ("ni" (("નિ") ("ણિ") ("નૈ"))) + ("nI" (("ની") ("ણી"))) + ("njaa" (("ઞા") ("ઞ્ચા"))) + ("njae" (("ઞૈ") ("ઞ્ઞૈ"))) + ("njaH" (("ઞઃ"))) + ("njai" (("ઞૈ") ("ઞ્ઞૈ"))) + ("njaM" (("ઞઁ"))) + ("njau" (("ઞૌ") ("ઞે") ("ઞ્ઞૌ"))) + ("nja" (("ઞ") ("ઞ્ચ") ("ઞ્ઞ"))) + ("njA" (("ઞા"))) + ("njee" (("ઞી") ("ઞ્ચી"))) + ("njei" (("ઞ્ચૈ") ("ઞૈ") ("ઞ્ઞૈ"))) + ("nje" (("ઞે") ("ઞ્ઞે") ("ઞ્ચે"))) + ("njE" (("ઞૈ") ("ઞ્ઞૈ"))) + ("njii" (("ઞી"))) + ("njI" (("ઞિ"))) + ("nji" (("ઞિ") ("ઞ્ઞિ") ("ઞ્ચિ"))) + ("njoo" (("ઞૂ") ("ઞ્ઞૂ"))) + ("njou" (("ઞે"))) + ("njo" (("ઞો") ("ઞ્ઞૌ") ("ઞ્ચો"))) + ("njO" (("ઞૌ") ("ઞ્ઞૌ") ("ઞ્ચૌ"))) + ("njR" (("ઞૃ"))) + ("njuu" (("ઞૂ") ("ઞ્ઞૂ") ("ઞ્ચૂ"))) + ("nju" (("ઞુ") ("ઞ્ઞુ") ("ઞ્ચુ"))) + ("njU" (("ઞૂ"))) + ("nj^" (("ઞ્"))) + ("nj" (("ઞ્") ("ઞ્ઞ્"))) + ("Noo" (("ણૂ"))) + ("noo" (("નૂ") ("ણૂ"))) + ("Nou" (("ણે"))) + ("nou" (("નૌ"))) + ("No" (("ણો") ("નૌ"))) + ("NO" (("ણૌ"))) + ("no" (("નો") ("ણો") ("નૌ"))) + ("nO" (("નૌ"))) + ("NR" (("ણૃ"))) + ("nR" (("નૃ"))) + ("Nuu" (("ણૂ"))) + ("nuu" (("નૂ") ("ણૂ"))) + ("Nu" (("ણુ"))) + ("NU" (("ણૂ"))) + ("nu" (("નુ") ("ણુ") ("ણ્"))) + ("nU" (("નૂ") ("ણૂ"))) + ("N^" (("ણ્"))) + ("N~" (("ણ્"))) + ("N_" (("ણ્"))) + ("N" (("ણ્") ("ણ્") ("ણ્ણ્") ("ન્") ("એન્"))) + ("n^" (("ન્"))) + ("n~" (("ન્"))) + ("n_" (("ન્"))) + ("n" (("ન્") ("ન્") ("ણ્") ("ણ્") ("ન્ન્") ("એન્"))) + ("oo" (("ઊ") ("ઔ"))) + ("ou" (("ઔ"))) + ("o" (("ઓ"))) + ("O" (("ઔ"))) + ("paa" (("પા"))) + ("pae" (("પૈ"))) + ("paH" (("પઃ"))) + ("pai" (("પૈ") ("પય્") ("પાય્"))) + ("paM" (("પઁ"))) + ("pau" (("પૌ") ("પૌ"))) + ("pa" (("પ"))) + ("Pa" (("પ"))) + ("pA" (("પા"))) + ("Pee" (("પિ"))) + ("pee" (("પિ") ("પૈ"))) + ("pei" (("પેય્") ("પૈ"))) + ("pe" (("પે") ("પિ"))) + ("pE" (("પૈ"))) + ("phaa" (("ફા"))) + ("phaH" (("ફઃ"))) + ("phai" (("ફૈ"))) + ("phaM" (("ફઁ"))) + ("phau" (("ફૌ") ("ફે"))) + ("pha" (("ફ"))) + ("phA" (("ફા"))) + ("phee" (("ફિ"))) + ("phei" (("ફૈ"))) + ("phe" (("ફે"))) + ("phE" (("ફૈ"))) + ("phii" (("ફિ"))) + ("phi" (("ફિ"))) + ("phI" (("ફી"))) + ("phoo" (("ફૂ"))) + ("phou" (("ફે"))) + ("pho" (("ફો") ("ફૌ"))) + ("phO" (("ફૌ"))) + ("phR" (("ફૃ"))) + ("phuu" (("ફૂ"))) + ("phu" (("ફુ"))) + ("phU" (("ફૂ"))) + ("ph^" (("ફ્"))) + ("ph" (("ફ્") ("પિ.એચ્."))) + ("pii" (("પિ"))) + ("pI" (("પિ"))) + ("Pi" (("પિ") )) + ("pi" (("પિ") ("પૈ") ("પ્પિ"))) + ("Poo" (("પૂ"))) + ("poo" (("પૂ") ("પૌ"))) + ("pou" (("પૌ"))) + ("po" (("પો"))) + ("pO" (("પૌ"))) + ("pR" (("પૃ"))) + ("puu" (("પૂ"))) + ("pu" (("પુ"))) + ("Pu" (("પુ"))) + ("pU" (("પૂ"))) + ("p^" (("પ્"))) + ("p" (("પ્") ("પ્પ્") ("પિ"))) + ("q" (("ક્યુ"))) + ("Q" (("ક્યૂ"))) + ("Raa" (("રા"))) + ("raa" (("રા") ("રા"))) + ("rae" (("રૈ"))) + ("Rae" (("રૈ"))) + ("raH" (("રઃ"))) + ("RaH" (("રઃ"))) + ("rai" (("રૈ") ("રાય્"))) + ("Rai" (("રૈ") ("રાય્"))) + ("raM" (("રઁ"))) + ("RaM" (("રઁ"))) + ("rau" (("રૌ"))) + ("Rau" (("રૌ"))) + ("ra" (("ર") ("ર"))) + ("Ra" (("ર") ("ર") ("રા"))) + ("rA" (("રા"))) + ("RA" (("રા"))) + ("ree" (("રી"))) + ("Ree" (("રી") ("રી") ("રૈ"))) + ("rei" (("રૈ") ("રેય્"))) + ("Rei" (("રૈ") ("રેય્"))) + ("re" (("રે"))) + ("Re" (("રે"))) + ("rE" (("રૈ"))) + ("RE" (("રૈ"))) + ("rii" (("રી"))) + ("Rii" (("રી"))) + ("rI" (("રિ"))) + ("RI" (("રિ"))) + ("Ri" (("રિ") ("રિ"))) + ("ri" (("રિ") ("રિ") ("રૈ") ("રૈ"))) + ("roo" (("રૂ"))) + ("Roo" (("રૂ") ("રૂ"))) + ("rou" (("રૌ"))) + ("Rou" (("રૌ"))) + ("Ro" (("રો"))) + ("ro" (("રો") ("રૌ"))) + ("rO" (("રૌ"))) + ("RO" (("રૌ"))) + ("rr" (("ઋ"))) + ("RR" (("ઋ"))) + ("rR" (("રૃ"))) + ("ruu" (("રૂ"))) + ("Ruu" (("રૂ") ("રૂ"))) + ("ru" (("રુ") ("રુ"))) + ("Ru" (("રુ") ("રુ"))) + ("rU" (("રૂ"))) + ("RU" (("રૂ"))) + ("r^" (("ઋ"))) + ("r~" (("ર્"))) + ("r_" (("ર્"))) + ("R^" (("ર્"))) + ("R~" (("ર્"))) + ("R_" (("ર્"))) + ("r" (("ર્") ("ર્") ("આર"))) + ("R" (("ર્") ("ર્") ("આર"))) + ("Saa" (("શા") ("સા"))) + ("saa" (("સા") ("શા"))) + ("Sae" (("શૈ"))) + ("sae" (("સૈ"))) + ("SaH" (("શઃ") ("ષા"))) + ("saH" (("સઃ"))) + ("Sai" (("શૈ") ("સૈ") ("સાય"))) + ("sai" (("સૈ") ("સાય્"))) + ("SaM" (("શઁ"))) + ("saM" (("સઁ"))) + ("Sau" (("શૌ") ("સૌ"))) + ("sau" (("સૌ") ("સે"))) + ("Sa" (("શ") ("સ"))) + ("SA" (("શા") ("સા"))) + ("sa" (("સ") ("શ"))) + ("sA" (("સા"))) + ("See" (("શિ") ("સિ"))) + ("see" (("સી") ("શી"))) + ("Sei" (("શૈ") ("સિ"))) + ("sei" (("સૈ"))) + ("Se" (("શે") ("સે") ("સિ"))) + ("SE" (("શૈ") ("એસ.ઇ."))) + ("se" (("સે") ("સિ"))) + ("sE" (("સૈ"))) + ("shaa" (("ષા"))) + ("Shaa" (("ષા"))) + ("shae" (("ષૈ"))) + ("Shae" (("ષૈ"))) + ("shaH" (("ષઃ"))) + ("ShaH" (("ષઃ"))) + ("shai" (("ષૈ"))) + ("Shai" (("ષૈ"))) + ("shaM" (("ષઁ"))) + ("ShaM" (("ષઁ"))) + ("shau" (("ષૌ") ("ષે"))) + ("Shau" (("ષૌ") ("ષૌ") ("ષે"))) + ("sha" (("ષ"))) + ("Sha" (("ષ") ("ષ") ("ષા"))) + ("shA" (("ષા"))) + ("ShA" (("ષા"))) + ("Shee" (("ષી"))) + ("shee" (("ષી") ("ષી"))) + ("shei" (("ષૈ"))) + ("Shei" (("ષૈ"))) + ("she" (("ષે") ("ષિ"))) + ("She" (("ષે") ("ષિ"))) + ("shE" (("ષૈ"))) + ("ShE" (("ષૈ"))) + ("shii" (("ષી"))) + ("Shii" (("ષી"))) + ("shi" (("ષિ"))) + ("Shi" (("ષિ"))) + ("shI" (("ષી"))) + ("ShI" (("ષી"))) + ("shoo" (("ષૂ"))) + ("Shoo" (("ષૂ") ("ષૂ"))) + ("shou" (("ષે"))) + ("Shou" (("ષે"))) + ("Sho" (("ષો"))) + ("sho" (("ષો") ("ષૌ"))) + ("shO" (("ષૌ"))) + ("ShO" (("ષૌ"))) + ("shR" (("ષૃ"))) + ("ShR" (("ષૃ"))) + ("shuu" (("ષૂ"))) + ("Shuu" (("ષૂ"))) + ("shu" (("ષુ"))) + ("Shu" (("ષુ") ("ષુ"))) + ("shU" (("ષૂ"))) + ("ShU" (("ષૂ"))) + ("sh^" (("ષ્"))) + ("sh" (("ષ્"))) + ("Sh^" (("ષ્"))) + ("Sh" (("ષ્") ("ષ્"))) + ("Sii" (("શિ"))) + ("sii" (("સી"))) + ("Si" (("શિ") ("સિ"))) + ("SI" (("શી") ("એસ્.ઐ."))) + ("si" (("સિ") ("શિ"))) + ("sI" (("સી"))) + ("Soo" (("શૂ") ("સૂ"))) + ("soo" (("સૂ") ("શૂ"))) + ("Sou" (("શે") ("સે"))) + ("sou" (("સે"))) + ("So" (("શો") ("સો") ("સૌ"))) + ("SO" (("શૌ"))) + ("so" (("સો") ("શો") ("સૌ"))) + ("sO" (("સૌ"))) + ("SR" (("શૃ") ("એસ.આર"))) + ("sR" (("સૃ"))) + ("Suu" (("શૂ"))) + ("suu" (("સૂ") ("શૂ"))) + ("Su" (("શુ") ("સુ"))) + ("SU" (("શૂ"))) + ("su" (("સુ") ("શુ"))) + ("sU" (("સૂ"))) + ("S^" (("શ્"))) + ("S" (("શ્") ("સ્") ("શ્શ્") ("એસ્"))) + ("s^" (("સ્"))) + ("s" (("સ્") ("શ્") ("સ્સ્") ("એસ્"))) + ("taa" (("ટા"))) + ("Taa" (("ઠા"))) + ("tae" (("ટૈ"))) + ("Tae" (("ઠૈ"))) + ("taH" (("ટઃ"))) + ("TaH" (("ઠઃ"))) + ("tai" (("ટૈ") ("ટાય્"))) + ("Tai" (("ઠૈ"))) + ("taM" (("ટઁ"))) + ("TaM" (("ઠઁ"))) + ("tau" (("ટૌ") ("ટે"))) + ("Tau" (("ઠૌ") ("ઠે"))) + ("ta" (("ટ") ("ર્ર") ("ઠ"))) + ("tA" (("ટા"))) + ("Ta" (("ઠ") ("ટ") ("ત"))) + ("TA" (("ઠા"))) + ("tea" (("ટી") ("ર્રિ"))) + ("tee" (("ટી") ("ર્રી"))) + ("Tee" (("ઠી"))) + ("tei" (("ટૈ") ("ટેય્"))) + ("Tei" (("ઠૈ"))) + ("te" (("ટે") ("ર્રે") ("ઠે"))) + ("tE" (("ટૈ"))) + ("Te" (("ઠે") ("ટે") ("તે"))) + ("TE" (("ઠૈ"))) + ("thaa" (("તા") ("ત્તા"))) + ("Thaa" (("થા") ("તા"))) + ("thae" (("તૈ"))) + ("Thae" (("થૈ"))) + ("thaH" (("તઃ"))) + ("ThaH" (("થઃ"))) + ("thai" (("તૈ"))) + ("Thai" (("થૈ") ("તૈ"))) + ("thaM" (("તઁ") ("ત્તઁ"))) + ("ThaM" (("થઁ"))) + ("thau" (("તૌ") ("તે"))) + ("Thau" (("થૌ") ("થે"))) + ("tha" (("ત") ("ધ") ("ત્ત") ("દ્ધ") ("થ"))) + ("thA" (("તા"))) + ("Tha" (("થ") ("ત"))) + ("ThA" (("થા"))) + ("thee" (("તી") ("તૈ"))) + ("Thee" (("થિ") ("તિ"))) + ("thei" (("તૈ") ("તેય્"))) + ("Thei" (("થૈ") ("તેય્"))) + ("the" (("તે"))) + ("thE" (("તૈ"))) + ("The" (("થે") ("દિ") ("તે"))) + ("ThE" (("થૈ"))) + ("thii" (("તી") ("ત્તી"))) + ("Thii" (("થિ"))) + ("thi" (("તિ") ("ત્તિ") ("ત્થિ") ("થિ") ("ધિ") ("દ્ધિ") ("તૈ"))) + ("thI" (("તી"))) + ("Thi" (("થિ") ("તિ") ("ત્થિ"))) + ("ThI" (("થી"))) + ("thoo" (("તૂ") ("તૌ"))) + ("Thoo" (("થૂ") ("તૂ"))) + ("thou" (("તે"))) + ("Thou" (("થે"))) + ("tho" (("તો") ("તૌ") ("ત્તો"))) + ("thO" (("તૌ") ("ત્તૌ"))) + ("Tho" (("થો"))) + ("ThO" (("થૌ"))) + ("thR" (("તૃ"))) + ("ThR" (("થૃ") ("તૃ"))) + ("thuu" (("તૂ"))) + ("Thuu" (("થૂ") ("તૂ"))) + ("thu" (("તુ") ("ત્તુ"))) + ("thU" (("તૂ"))) + ("Thu" (("થુ") ("તુ"))) + ("ThU" (("થૂ") ("તૂ"))) + ("th^" (("ત્"))) + ("th" (("ત્") ("ત્ત્"))) + ("Th^" (("થ્"))) + ("Th" (("થ્"))) + ("tii" (("ટી"))) + ("Tii" (("ઠી"))) + ("ti" (("ટિ") ("ટ્ટિ") ("ર્રિ") ("ઠિ") ("ટૈ"))) + ("tI" (("ટી") ("ર્રી"))) + ("Ti" (("ઠિ") ("ટિ") ("તિ") ("તૈ"))) + ("TI" (("ઠી"))) + ("too" (("ટૂ") ("ર્રૂ"))) + ("Too" (("ઠૂ") ("ટૂ"))) + ("tou" (("ટે"))) + ("Tou" (("ઠે"))) + ("to" (("ટો") ("ટુ") ("ર્રુ"))) + ("tO" (("ટૌ"))) + ("To" (("ઠો") ("ટુ") ("તો"))) + ("TO" (("ઠૌ"))) + ("tR" (("ટૃ"))) + ("TR" (("ઠૃ"))) + ("TTa" (("ટ્ટ"))) + ("TTI" (("ટિ.ટિ.ઐ."))) + ("TTR" (("ટિ.ટિ.આર્."))) + ("TT" (("ટિ.ટિ."))) + ("tuu" (("ટૂ") ("ર્રૂ"))) + ("Tuu" (("ઠૂ"))) + ("tu" (("ટુ") ("ર્રુ") ("ટ્ટુ"))) + ("tU" (("ટૂ") ("ર્રૂ"))) + ("Tu" (("ઠુ") ("ટુ"))) + ("TU" (("ઠૂ"))) + ("t^" (("ટ્"))) + ("t" (("ટ્") ("ટ્ટ્") ("ર્ર્") ("ત્") ("ટિ"))) + ("T^" (("ઠ્"))) + ("T" (("ઠ્") ("ટિ"))) + ("uu" (("ઊ"))) + ("u" (("ઉ") ("ઊ") ("યુ"))) + ("U" (("ઊ"))) + ("vaa" (("વા"))) + ("Vaa" (("વા"))) + ("vae" (("વૈ"))) + ("vaH" (("વઃ"))) + ("vai" (("વૈ") ("વય્"))) + ("vaM" (("વઁ"))) + ("vau" (("વૌ") ("વે"))) + ("va" (("વ") ("વા"))) + ("Va" (("વ") ("વ્વ") ("વા"))) + ("vA" (("વા"))) + ("vee" (("વિ") ("વૈ"))) + ("vei" (("વૈય્") ("વૈ"))) + ("ve" (("વે"))) + ("vE" (("વૈ"))) + ("vii" (("વિ"))) + ("vi" (("વિ"))) + ("vI" (("વિ"))) + ("Vi" (("વિ"))) + ("voo" (("વૂ"))) + ("vou" (("વે"))) + ("vo" (("વો") ("વૌ"))) + ("vO" (("વૌ"))) + ("vR" (("વૃ"))) + ("vuu" (("વૂ"))) + ("vu" (("વુ"))) + ("vU" (("વૂ"))) + ("V" (("વિ"))) + ("v^" (("વ્"))) + ("v" (("વ્") ("વ્વ્") ("વિ"))) + ("waa" (("વા"))) + ("wae" (("વૈ"))) + ("waH" (("વઃ"))) + ("wai" (("વૈ"))) + ("waM" (("વઁ"))) + ("wau" (("વૌ"))) + ("wa" (("વ"))) + ("wA" (("વા"))) + ("wee" (("વિ"))) + ("wei" (("વૈ"))) + ("we" (("વે"))) + ("wE" (("વૈ"))) + ("wii" (("વિ"))) + ("wi" (("વિ"))) + ("wI" (("વિ"))) + ("woo" (("વૂ"))) + ("wou" (("વે"))) + ("wo" (("વો"))) + ("wO" (("વૌ"))) + ("wR" (("વૃ"))) + ("wuu" (("વૂ"))) + ("wu" (("વુ"))) + ("wU" (("વૂ"))) + ("w^" (("વ્"))) + ("w" (("વ્") ("વ્વ્") ("ડબ્લ્યૂ"))) + ("xaa" (("ક્ષા"))) + ("xaH" (("ક્ષઃ"))) + ("xai" (("ક્ષૈ"))) + ("xaM" (("ક્ષઁ"))) + ("xau" (("ક્ષૌ") ("ક્ષે"))) + ("xa" (("ક્ષ") ("ક્સ") ("ક્સે"))) + ("xA" (("ક્ષા"))) + ("xee" (("ક્ષી"))) + ("xei" (("ક્ષૈ"))) + ("xe" (("ક્ષે") ("ક્ષૈ") ("ક્સે") ("ક્સિ") ("ક્ષિ"))) + ("xE" (("ક્ષૈ"))) + ("xii" (("ક્ષી"))) + ("xi" (("ક્ષિ") ("ક્સિ"))) + ("xI" (("ક્ષી"))) + ("xoo" (("ક્ષૂ"))) + ("xou" (("ક્ષે"))) + ("xo" (("ક્ષો"))) + ("xO" (("ક્ષૌ"))) + ("xR" (("ક્ષૃ"))) + ("xuu" (("ક્ષૂ"))) + ("xu" (("ક્ષુ") ("ક્સુ"))) + ("xU" (("ક્ષૂ"))) + ("X" (("એક્સ્"))) + ("x^" (("ક્ષ્"))) + ("x" (("ક્ષ્") ("ક્સ્") ("એક્સ્"))) + ("yaa" (("યા"))) + ("Yaa" (("યા"))) + ("yae" (("યૈ"))) + ("yaH" (("યઃ") ("યઃ"))) + ("yai" (("યૈ"))) + ("Yai" (("યૈ"))) + ("yaM" (("યઁ") ("યઁ"))) + ("yau" (("યૌ") ("યે"))) + ("Yau" (("યૌ") ("યે"))) + ("ya" (("ય"))) + ("Ya" (("ય"))) + ("yA" (("યા"))) + ("YA" (("યા"))) + ("yei" (("યૈ"))) + ("Yei" (("યૈ"))) + ("ye" (("યે") ("યૈ"))) + ("Ye" (("યે") ("યૈ"))) + ("yE" (("યૈ"))) + ("YE" (("યૈ") ("યૈ"))) + ("yii" (("યી"))) + ("Yii" (("યી"))) + ("yi" (("યિ"))) + ("yI" (("યિ"))) + ("Yi" (("યિ"))) + ("YI" (("યી"))) + ("yoo" (("યૂ"))) + ("Yoo" (("યૂ"))) + ("you" (("યે") ("યૂ") ("યૂ") ("યે"))) + ("yo" (("યો"))) + ("Yo" (("યો") ("યૌ"))) + ("yO" (("યૌ"))) + ("YO" (("યૌ"))) + ("yR" (("યૃ"))) + ("YR" (("યૃ"))) + ("yuu" (("યૂ"))) + ("Yuu" (("યૂ"))) + ("yu" (("યુ"))) + ("Yu" (("યુ"))) + ("yU" (("યૂ"))) + ("YU" (("યૂ"))) + ("y^" (("ય્"))) + ("y" (("ય્") ("ય્ય્") ("વૈ"))) + ("Y" (("વૈ"))) + ("zaa" (("શા") ("સા"))) + ("zaH" (("શઃ"))) + ("zai" (("શૈ"))) + ("zaM" (("શઁ"))) + ("zau" (("શૌ"))) + ("za" (("શ") ("સ"))) + ("zA" (("શા"))) + ("zee" (("શી") ("સી"))) + ("zei" (("શૈ"))) + ("ze" (("શે"))) + ("zE" (("શૈ"))) + ("zhaa" (("ષા"))) + ("zhae" (("ષૈ"))) + ("zhaH" (("ષઃ"))) + ("zhai" (("ષૈ"))) + ("zhaM" (("ષઁ"))) + ("zhau" (("ષૌ") ("ષે"))) + ("zha" (("ષ"))) + ("zhA" (("ષા"))) + ("zhee" (("ષી"))) + ("zhei" (("ષૈ"))) + ("zhe" (("ષે"))) + ("zhE" (("ષૈ"))) + ("zhii" (("ષી"))) + ("zhi" (("ષિ"))) + ("zhI" (("ષી"))) + ("zhoo" (("ષૂ"))) + ("zhou" (("ષે"))) + ("zho" (("ષો"))) + ("zhO" (("ષૌ"))) + ("zhR" (("ષૃ"))) + ("zhuu" (("ષૂ"))) + ("zhu" (("ષુ"))) + ("zhU" (("ષૂ"))) + ("zh^" (("ષ્"))) + ("zh" (("ષ્"))) + ("zii" (("શી"))) + ("zi" (("શિ") ("સિ"))) + ("zI" (("શી"))) + ("zoo" (("શૂ") ("સૂ"))) + ("zou" (("શે"))) + ("zo" (("શો"))) + ("zO" (("શૌ"))) + ("zR" (("શૃ"))) + ("zuu" (("શૂ"))) + ("zu" (("શુ") ("સુ"))) + ("zU" (("શૂ"))) + ("z^" (("શ્"))) + ("z" (("શ્") ("સ્") ("ઇસડ્"))) +) +) + + +(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: diff --git a/input-methods/m17n/swanalekha/gu-swanalekha.png b/input-methods/m17n/swanalekha/gu-swanalekha.png Binary files differnew file mode 100755 index 0000000..6ef389b --- /dev/null +++ b/input-methods/m17n/swanalekha/gu-swanalekha.png diff --git a/input-methods/m17n/swanalekha/hi-swanalekha.mim b/input-methods/m17n/swanalekha/hi-swanalekha.mim new file mode 100755 index 0000000..d1374e9 --- /dev/null +++ b/input-methods/m17n/swanalekha/hi-swanalekha.mim @@ -0,0 +1,1344 @@ +(input-method hi swanalekha) + +(description "Swanalekha Hindi input method") + + +(title "hindi") +(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 + ("~" ((""))) + ("_" ((""))) + ("aa" (("आ"))) + ("@aa" (("ा"))) + ("ae" (("ऎ"))) + ("aH" (("अः"))) + ("@ah" (("ः"))) + ("@aH" (("ः"))) + ("ai" (("ऐ"))) + ("aM" (("अँ"))) + ("au" (("औ"))) + ("a" (("अ") ("आ") ("ए"))) + ("A" (("आ") ("ए"))) + ("baa" (("बा"))) + ("Baa" (("भा") ("बा"))) + ("bae" (("बै"))) + ("baH" (("बः"))) + ("BaH" (("भः"))) + ("bai" (("बै") ("बाय्"))) + ("Bai" (("भै"))) + ("baM" (("बँ"))) + ("BaM" (("भँ"))) + ("bau" (("बौ") ("बौ") ("भौ"))) + ("Bau" (("भौ") ("भे"))) + ("ba" (("ब"))) + ("bA" (("बा"))) + ("Ba" (("भ") ("ब") ("बा"))) + ("BA" (("भा") ("बि.ए."))) + ("bee" (("बी"))) + ("Bee" (("भी"))) + ("bei" (("बै"))) + ("Bei" (("भै"))) + ("be" (("बे"))) + ("bE" (("बै"))) + ("Be" (("भे"))) + ("BE" (("भै"))) + ("bhaa" (("भा"))) + ("bhae" (("भै"))) + ("bhaH" (("भः"))) + ("bhai" (("भै") ("भाय्"))) + ("bhaM" (("भँ"))) + ("bhau" (("भौ") ("भे"))) + ("bha" (("भ"))) + ("bhA" (("भा"))) + ("bhee" (("भी"))) + ("bhei" (("भै"))) + ("bhe" (("भे"))) + ("bhE" (("भै"))) + ("bhii" (("भी"))) + ("bhi" (("भि"))) + ("bhI" (("भि"))) + ("bhoo" (("भू"))) + ("bhou" (("भे"))) + ("bho" (("भो"))) + ("bhO" (("भौ"))) + ("bhR" (("भृ"))) + ("bhuu" (("भू"))) + ("bhu" (("भु"))) + ("bhU" (("भू"))) + ("bh^" (("भ्"))) + ("bh" (("भ्"))) + ("bii" (("बी"))) + ("Bii" (("भी"))) + ("bi" (("बि") ("बै"))) + ("bI" (("बी"))) + ("Bi" (("भि") ("बै"))) + ("BI" (("भी"))) + ("boo" (("बू") ("बौ"))) + ("Boo" (("भू"))) + ("bou" (("बौ"))) + ("Bou" (("भे"))) + ("bo" (("बो"))) + ("bO" (("बौ"))) + ("Bo" (("भो") ("बौ"))) + ("BO" (("भौ"))) + ("bR" (("बृ"))) + ("BR" (("भृ"))) + ("buu" (("बू"))) + ("Buu" (("भू"))) + ("bu" (("बु"))) + ("bU" (("बू"))) + ("Bu" (("भु") ("बु"))) + ("BU" (("भू"))) + ("b^" (("ब्"))) + ("b" (("ब्") ("ब्ब्") ("बि"))) + ("B^" (("भ्"))) + ("B" (("भ्") ("ब्") ("बि"))) + ("caa" (("का"))) + ("cae" (("कै"))) + ("cai" (("कै"))) + ("cau" (("कौ"))) + ("ca" (("क") ("का") ("कै"))) + ("cA" (("का"))) + ("cee" (("कि"))) + ("cei" (("कै"))) + ("ce" (("के") ("स्"))) + ("cE" (("कै"))) + ("chaa" (("चा"))) + ("Chaa" (("छा"))) + ("chae" (("चै"))) + ("Chae" (("छै"))) + ("chaH" (("चः"))) + ("ChaH" (("छः"))) + ("chai" (("चै") ("चाय्"))) + ("Chai" (("छै"))) + ("chaM" (("चँ"))) + ("ChaM" (("छँ"))) + ("chau" (("चौ"))) + ("Chau" (("छौ") ("छे"))) + ("cha" (("च") ("च्च") ("च्छ"))) + ("chA" (("चा"))) + ("Cha" (("छ") ("च") ("च्च"))) + ("ChA" (("छा"))) + ("chee" (("ची") ("च्ची"))) + ("Chee" (("छी"))) + ("chei" (("चै"))) + ("Chei" (("छै"))) + ("che" (("चे") ("च्चे"))) + ("chE" (("चै"))) + ("Che" (("छे"))) + ("ChE" (("छै"))) + ("chhaa" (("छा"))) + ("chhae" (("छै"))) + ("chhaH" (("छः"))) + ("chhai" (("छै"))) + ("chhaM" (("छँ"))) + ("chhau" (("छौ") ("छे"))) + ("chha" (("छ") ("च्च"))) + ("chhA" (("छा"))) + ("chhee" (("छी"))) + ("chhei" (("छै"))) + ("chhe" (("छे"))) + ("chhE" (("छै"))) + ("chhii" (("छी"))) + ("chhI" (("छि"))) + ("chhi" (("छी"))) + ("chhoo" (("छू"))) + ("chhou" (("छे"))) + ("chho" (("छो"))) + ("chhO" (("छौ"))) + ("chhR" (("छृ"))) + ("chhuu" (("छू"))) + ("chhu" (("छु"))) + ("chhU" (("छू"))) + ("chh^" (("छ्"))) + ("chh" (("छ्"))) + ("chii" (("ची"))) + ("Chii" (("छी"))) + ("chi" (("चि") ("च्चि") ("चै"))) + ("chI" (("ची"))) + ("Chi" (("छि") ("चि"))) + ("ChI" (("छी"))) + ("choo" (("चू") ("च्चू") ("चौ"))) + ("Choo" (("छू"))) + ("chou" (("चे"))) + ("Chou" (("छे"))) + ("cho" (("चो") ("चौ"))) + ("chO" (("चौ"))) + ("Cho" (("छो"))) + ("ChO" (("छौ"))) + ("chR" (("चृ"))) + ("ChR" (("छृ"))) + ("chuu" (("चू") ("च्चू"))) + ("Chuu" (("छू"))) + ("chu" (("चु") ("च्यु"))) + ("chU" (("चू"))) + ("Chu" (("छु") ("चु"))) + ("ChU" (("छू"))) + ("ch^" (("च्"))) + ("ch" (("च्") ("च्च्") ("क्क्"))) + ("Ch^" (("छ्"))) + ("Ch" (("छ्"))) + ("ci" (("कि") ("सि") ("सै"))) + ("cI" (("की"))) + ("cka" (("क"))) + ("ck" (("क्क्"))) + ("coo" (("कू"))) + ("cou" (("के"))) + ("co" (("को"))) + ("cO" (("को"))) + ("cR" (("कृ"))) + ("cuu" (("कू"))) + ("cu" (("कु"))) + ("cU" (("कू"))) + ("c" (("क्") ("सि"))) + ("C" (("सि"))) + ("Daa" (("डा"))) + ("daa" (("दा") ("टा"))) + ("Dae" (("डै"))) + ("dae" (("दै"))) + ("DaH" (("डः"))) + ("daH" (("दः"))) + ("Dai" (("डै"))) + ("dai" (("दै") ("डाय्"))) + ("DaM" (("डँ"))) + ("daM" (("दँ"))) + ("Dau" (("डौ") ("डे"))) + ("dau" (("दौ") ("दे"))) + ("Da" (("ड") ("द") ("ठ"))) + ("DA" (("डा"))) + ("da" (("द") ("ट") ("ड"))) + ("dA" (("दा") ("टा"))) + ("Dee" (("डी"))) + ("dee" (("दी") ("टी"))) + ("Dei" (("डै"))) + ("dei" (("दै") ("डैय्"))) + ("De" (("डे") ("टे"))) + ("DE" (("डै"))) + ("de" (("दे") ("टे") ("ते"))) + ("dE" (("दै") ("तै"))) + ("Dhaa" (("ढा"))) + ("dhaa" (("धा"))) + ("Dhae" (("ढै"))) + ("dhae" (("धै"))) + ("DhaH" (("ढः"))) + ("dhaH" (("धः"))) + ("Dhai" (("ढै"))) + ("dhai" (("धै"))) + ("DhaM" (("ढँ"))) + ("dhaM" (("धँ"))) + ("Dhau" (("ढौ") ("ढे"))) + ("dhau" (("धौ") ("धे"))) + ("Dha" (("ढ"))) + ("DhA" (("ढा"))) + ("dha" (("ध"))) + ("dhA" (("धा"))) + ("Dhee" (("ढी"))) + ("dhee" (("धि"))) + ("Dhei" (("ढै"))) + ("dhei" (("धै"))) + ("Dhe" (("ढे"))) + ("DhE" (("ढै"))) + ("dhe" (("धे"))) + ("dhE" (("धै"))) + ("Dhii" (("ढी"))) + ("dhii" (("धि"))) + ("Dhi" (("ढि"))) + ("DhI" (("ढी"))) + ("dhi" (("धि"))) + ("dhI" (("धि"))) + ("Dhoo" (("ढू"))) + ("dhoo" (("धू"))) + ("Dhou" (("ढे"))) + ("dhou" (("धे"))) + ("Dho" (("ढो"))) + ("DhO" (("ढौ"))) + ("dho" (("धो"))) + ("dhO" (("धौ"))) + ("DhR" (("ढृ"))) + ("dhR" (("धृ"))) + ("Dhuu" (("ढू"))) + ("dhuu" (("धू"))) + ("Dhu" (("ढु"))) + ("DhU" (("ढू"))) + ("dhu" (("धु"))) + ("dhU" (("धू"))) + ("Dh^" (("ढ्"))) + ("Dh" (("ढ्"))) + ("dh^" (("ध्"))) + ("dh" (("ध्"))) + ("Dii" (("डी"))) + ("dii" (("दी") ("टी"))) + ("Di" (("डि"))) + ("DI" (("डी"))) + ("dI" (("दि") ("टि"))) + ("di" (("दि") ("टि") ("धि") ("थि") ("डै"))) + ("Doo" (("डू"))) + ("doo" (("दू"))) + ("Dou" (("डे"))) + ("dou" (("दे"))) + ("Do" (("डो"))) + ("DO" (("डौ"))) + ("do" (("दो"))) + ("dO" (("दौ"))) + ("DR" (("डृ"))) + ("dR" (("दृ"))) + ("Duu" (("डू"))) + ("duu" (("दू"))) + ("Du" (("डु") ("दु"))) + ("DU" (("डू"))) + ("du" (("दु") ("टु") ("दुः"))) + ("dU" (("दू"))) + ("D^" (("ड्"))) + ("D" (("ड्") ("द्") ("डि"))) + ("d^" (("द्"))) + ("d" (("द्") ("ट्") ("डि") ("द्द्"))) + ("ee" (("ई"))) + ("ei" (("ऐ"))) + ("E" (("ऎ") ("इ"))) + ("e" (("ए") ("इ"))) + ("faa" (("फा"))) + ("faH" (("फः"))) + ("fai" (("फै"))) + ("faM" (("फँ"))) + ("fau" (("फौ") ("फे"))) + ("fa" (("फ"))) + ("fA" (("फा"))) + ("fee" (("फी"))) + ("fei" (("फै"))) + ("fe" (("फे"))) + ("fE" (("फै"))) + ("fii" (("फी"))) + ("fi" (("फि"))) + ("fI" (("फी"))) + ("foo" (("फू"))) + ("fou" (("फे"))) + ("fo" (("फो"))) + ("fO" (("फौ"))) + ("fR" (("फृ"))) + ("fuu" (("फू"))) + ("fu" (("फु"))) + ("fU" (("फू"))) + ("f^" (("फ्"))) + ("f" (("फ्") ("एफ्"))) + ("gaa" (("गा"))) + ("Gaa" (("घा") ("ग्गा"))) + ("gae" (("गै"))) + ("Gae" (("घै") ("ग्गै"))) + ("gaH" (("गः"))) + ("GaH" (("घः"))) + ("gai" (("गै"))) + ("Gai" (("घै") ("गय्") ("गेय्") ("ग्गै"))) + ("gaM" (("गँ"))) + ("GaM" (("घँ"))) + ("gau" (("गौ") ("गे"))) + ("Gau" (("घौ") ("गौ") ("घे"))) + ("ga" (("ग") ("ज") ("क") ("ख"))) + ("gA" (("गा"))) + ("Ga" (("घ") ("ग") ("ग्ग") ("ज"))) + ("GA" (("घा") ("ग्गा"))) + ("gee" (("गी"))) + ("Gee" (("घि") ("ग्गि"))) + ("gei" (("गै"))) + ("Gei" (("घै") ("ग्गै"))) + ("ge" (("गे"))) + ("gE" (("गै"))) + ("Ge" (("घे") ("गे") ("ग्गे") ("जे"))) + ("GE" (("घै") ("ग्गै"))) + ("ghaa" (("घा"))) + ("ghae" (("घै"))) + ("ghaH" (("घः"))) + ("ghai" (("घै"))) + ("ghaM" (("घँ"))) + ("ghau" (("घौ"))) + ("gha" (("घ") ("ख"))) + ("ghA" (("घा"))) + ("ghee" (("घि"))) + ("ghei" (("घै"))) + ("ghe" (("घे"))) + ("ghE" (("घै"))) + ("ghii" (("घि"))) + ("ghi" (("घि"))) + ("ghI" (("घि"))) + ("ghoo" (("घू"))) + ("ghou" (("घे"))) + ("gho" (("घो"))) + ("ghO" (("घौ"))) + ("ghR" (("घृ"))) + ("ghuu" (("घू"))) + ("ghu" (("घु"))) + ("ghU" (("घू"))) + ("gh^" (("घ्"))) + ("gh" (("घ्"))) + ("gii" (("गी"))) + ("Gii" (("घी") ("ग्गी"))) + ("gi" (("गि") ("कि") ("जि"))) + ("gI" (("गी"))) + ("GI" (("घि") ("ग्गि") ("ग्गि"))) + ("Gi" (("घि") ("ग्गी"))) + ("goo" (("गू") ("गौ"))) + ("Goo" (("घू") ("ग्गू") ("घौ") ("ग्गौ"))) + ("gou" (("गे"))) + ("Gou" (("घे"))) + ("go" (("गो") ("गौ"))) + ("gO" (("गौ"))) + ("Go" (("घो") ("गौ") ("गो") ("ग्गो"))) + ("GO" (("घौ"))) + ("gR" (("गृ"))) + ("GR" (("घृ") ("ग्गृ"))) + ("guu" (("गू"))) + ("Guu" (("घू") ("ग्गू"))) + ("gu" (("गु"))) + ("gU" (("गू"))) + ("Gu" (("घु") ("गु") ("ग्गु"))) + ("GU" (("घू") ("ग्गू"))) + ("g^" (("ग्"))) + ("g" (("ग्") ("जि"))) + ("G^" (("घ्"))) + ("G" (("घ्") ("जि") ("ग्गि"))) + ("haa" (("हा"))) + ("haH" (("हः"))) + ("hai" (("है") ("हाय्"))) + ("haM" (("हँ"))) + ("hau" (("हौ"))) + ("ha" (("ह") ("हा"))) + ("hA" (("हा"))) + ("hee" (("ही"))) + ("hei" (("है") ("हैय्"))) + ("he" (("हे") ("हि"))) + ("hE" (("है"))) + ("hii" (("ही"))) + ("hi" (("हि") ("हाय्"))) + ("hI" (("ही"))) + ("hoo" (("हू"))) + ("hou" (("हौ"))) + ("ho" (("हो") ("हौ"))) + ("hO" (("हौ"))) + ("hR" (("हृ"))) + ("huu" (("हू"))) + ("hu" (("हु"))) + ("hU" (("हू"))) + ("H" (("एच्च्"))) + ("h^" (("ह्"))) + ("h" (("ह्") ("एच्") ("एच्च्"))) + ("ii" (("ई"))) + ("@ii" (("ी"))) + ("i" (("इ") ("ई") ("ऐ"))) + ("I" (("ई") ("ऐ"))) + ("jaa" (("जा"))) + ("Jaa" (("झा"))) + ("jae" (("जै"))) + ("Jae" (("झै"))) + ("jaH" (("जः"))) + ("JaH" (("झः"))) + ("jai" (("जै") ("जय्"))) + ("Jai" (("झै") ("जय्"))) + ("jaM" (("जँ"))) + ("JaM" (("झँ"))) + ("jau" (("जौ") ("जे"))) + ("Jau" (("झौ") ("झे"))) + ("ja" (("ज") ("जे"))) + ("jA" (("जा"))) + ("Ja" (("झ") ("ज") ("जे"))) + ("JA" (("झा"))) + ("jee" (("जी"))) + ("Jee" (("झी") ("जी"))) + ("jei" (("जै"))) + ("Jei" (("झै"))) + ("je" (("जे") ("जि"))) + ("jE" (("जै"))) + ("Je" (("झे"))) + ("JE" (("झै"))) + ("jhaa" (("झा"))) + ("jhae" (("झै"))) + ("jhaH" (("झः"))) + ("jhai" (("झै"))) + ("jhaM" (("झँ"))) + ("jhau" (("झौ") ("झे"))) + ("jha" (("झ"))) + ("jhA" (("झा"))) + ("jhee" (("झि"))) + ("jhei" (("झै"))) + ("jhe" (("झे"))) + ("jhE" (("झै"))) + ("jhii" (("झि"))) + ("jhi" (("झि"))) + ("jhI" (("झि"))) + ("jhoo" (("झू") ("झौ"))) + ("jhou" (("झे"))) + ("jho" (("झो"))) + ("jhO" (("झौ"))) + ("jhR" (("झृ"))) + ("jhuu" (("झू"))) + ("jhu" (("झु"))) + ("jhU" (("झू"))) + ("jh^" (("झ्"))) + ("jh" (("झ्"))) + ("jii" (("जी"))) + ("Jii" (("झी"))) + ("jI" (("जि"))) + ("ji" (("जि") ("जै"))) + ("Ji" (("झि") ("जि") ("जै"))) + ("JI" (("झी"))) + ("joo" (("जू"))) + ("Joo" (("झू") ("जू") ("झौ"))) + ("jou" (("जे"))) + ("Jou" (("झे"))) + ("jo" (("जो"))) + ("jO" (("जौ"))) + ("Jo" (("झो") ("जौ") ("जो"))) + ("JO" (("झौ"))) + ("jR" (("जृ"))) + ("JR" (("झृ") ("जे.आर्"))) + ("juu" (("जू"))) + ("Juu" (("झू") ("जू"))) + ("ju" (("जु"))) + ("jU" (("जू"))) + ("Ju" (("झु") ("जु"))) + ("JU" (("झू") ("जे.यु."))) + ("j^" (("ज्"))) + ("j" (("ज्") ("जे"))) + ("J" (("झ्") ("जे"))) + ("kaa" (("का") ("गा"))) + ("Kaa" (("खा"))) + ("kae" (("कै"))) + ("Kae" (("खै"))) + ("kaH" (("कः"))) + ("KaH" (("खः"))) + ("kai" (("कै") ("कय्"))) + ("Kai" (("खै"))) + ("kaM" (("कँ"))) + ("KaM" (("खँ"))) + ("kau" (("कौ") ("के"))) + ("Kau" (("खौ"))) + ("ka" (("क") ("ग") ("ख") ("घ"))) + ("kA" (("का"))) + ("Ka" (("ख") ("क") ("क्क"))) + ("KA" (("खा"))) + ("kee" (("की"))) + ("Kee" (("खि") ("कि"))) + ("kei" (("कै") ("केय्"))) + ("Kei" (("खै"))) + ("ke" (("के"))) + ("kE" (("कै"))) + ("Ke" (("खे") ("के"))) + ("KE" (("खै"))) + ("khaa" (("खा"))) + ("khae" (("खै"))) + ("khaH" (("खः"))) + ("khai" (("खै"))) + ("khaM" (("खँ"))) + ("khau" (("खौ") ("खे"))) + ("kha" (("ख") ("क्क") ("घ"))) + ("khA" (("खा"))) + ("khee" (("खि"))) + ("khei" (("खै"))) + ("khe" (("खे"))) + ("khE" (("खै"))) + ("khii" (("खि"))) + ("khI" (("खि"))) + ("khi" (("खि") ("क्कि"))) + ("khoo" (("खू"))) + ("khou" (("खे"))) + ("kho" (("खो"))) + ("khO" (("खौ"))) + ("khR" (("खृ"))) + ("khuu" (("खू"))) + ("khu" (("खु") ("घु"))) + ("khU" (("खू"))) + ("kh^" (("ख्"))) + ("kh" (("ख्") ("घ्"))) + ("Kii" (("खि"))) + ("ki" (("कि") ("गि") ("घि") ("खि") ("कै"))) + ("KI" (("ख"))) + ("Ki" (("खि") ("कि"))) + ("koo" (("कू") ("क"))) + ("Koo" (("खू") ("कू") ("कौ"))) + ("kou" (("के"))) + ("Kou" (("खे"))) + ("ko" (("को"))) + ("kO" (("को"))) + ("Ko" (("खो") ("को") ("कौ"))) + ("KO" (("खौ"))) + ("kR" (("कृ"))) + ("KR" (("खृ"))) + ("kuu" (("कू"))) + ("Kuu" (("खू") ("कू"))) + ("ku" (("कु") ("कू"))) + ("kU" (("कू"))) + ("Ku" (("खु") ("कु"))) + ("KU" (("खू"))) + ("k^" (("क्"))) + ("k" (("क्") ("क्क्") ("के"))) + ("K^" (("ख्"))) + ("K" (("ख्") ("के"))) + ("laa" (("ला") ("ला"))) + ("Laa" (("ला") ("ला"))) + ("lae" (("लै"))) + ("Lae" (("लै") ("लै"))) + ("laH" (("लः"))) + ("LaH" (("लः"))) + ("lai" (("लै"))) + ("Lai" (("लै"))) + ("laM" (("लँ"))) + ("LaM" (("लँ"))) + ("lau" (("लौ"))) + ("Lau" (("लौ") ("लौ") ("ले"))) + ("la" (("ल") ("ल"))) + ("La" (("ल") ("ल"))) + ("lA" (("ला"))) + ("LA" (("ला"))) + ("lee" (("ली") ("ली"))) + ("Lee" (("ली") ("ली"))) + ("lei" (("लै"))) + ("Lei" (("लै"))) + ("le" (("ले") ("ले"))) + ("Le" (("ले") ("ले"))) + ("lE" (("लै"))) + ("LE" (("लै") ("लै"))) + ("lii" (("ली"))) + ("Lii" (("ली"))) + ("Li" (("लि") ("लि"))) + ("li" (("लि") ("लि") ("लै") ("लै"))) + ("lI" (("ली"))) + ("LI" (("ली"))) + ("Loo" (("लू") ("लू"))) + ("loo" (("लू") ("लौ"))) + ("lou" (("ले"))) + ("Lou" (("ले"))) + ("lo" (("लो") ("लौ"))) + ("Lo" (("लो") ("लौ") ("लो"))) + ("lO" (("लौ"))) + ("LO" (("लौ"))) + ("lR" (("लृ"))) + ("LR" (("लृ"))) + ("luu" (("लू"))) + ("Luu" (("लू") ("लू"))) + ("lu" (("लु") ("लु"))) + ("Lu" (("लु") ("लु"))) + ("lU" (("लू"))) + ("LU" (("लू"))) + ("l^" (("ल्"))) + ("l~" (("ल्"))) + ("l_" (("ल्"))) + ("L^" (("ल्"))) + ("L~" (("ल्"))) + ("L_" (("ल्"))) + ("L" (("ल्") ("ल्") ("एल्") ("ल्ल्"))) + ("l" (("ल्") ("ल्") ("ल्") ("एल्"))) + ("maa" (("मा"))) + ("mae" (("मै"))) + ("maH" (("मः"))) + ("mai" (("मै") ("मय्"))) + ("maM" (("मँ"))) + ("mau" (("मौ") ("मे"))) + ("ma" (("म") ("म्म"))) + ("mA" (("मा"))) + ("mee" (("मी"))) + ("mei" (("मेय्") ("मै"))) + ("me" (("मे"))) + ("mE" (("मै"))) + ("mii" (("मी"))) + ("mi" (("मि"))) + ("mI" (("मि"))) + ("moo" (("मू") ("मौ"))) + ("mou" (("मे"))) + ("mo" (("मो") ("मौ"))) + ("mO" (("मौ"))) + ("mR" (("मृ"))) + ("muu" (("मू"))) + ("mu" (("मु"))) + ("mU" (("मू"))) + ("m^" (("म्"))) + ("m" (("म्") )) + ("m~" (("ँ"))) + ("m_" (("ँ"))) + ("Naa" (("णा") ("ना"))) + ("naa" (("ना") ("णा"))) + ("Nae" (("णै"))) + ("nae" (("नै"))) + ("NaH" (("णः"))) + ("naH" (("नः"))) + ("Nai" (("णै"))) + ("nai" (("नै") ("नाय्"))) + ("NaM" (("णँ"))) + ("naM" (("नँ"))) + ("Nau" (("णौ") ("णे"))) + ("nau" (("नौ") ("नौ"))) + ("Na" (("ण") ("न") ("ना") ("ण्ण"))) + ("NA" (("णा"))) + ("na" (("न") ("ण"))) + ("nA" (("ना"))) + ("Nee" (("णी") ("णै") ("नि"))) + ("nee" (("नी"))) + ("Nei" (("णै"))) + ("nei" (("नेय्") ("नै"))) + ("Ne" (("णे"))) + ("NE" (("णै"))) + ("ne" (("ने") ("न्") ("ण्"))) + ("nE" (("नै"))) + ("ngaa" (("ङा"))) + ("ngai" (("ङै"))) + ("ngaM" (("ङँ"))) + ("ngau" (("ङौ"))) + ("nga" (("ङ") ("ङ्ङ"))) + ("ngA" (("ङा"))) + ("ngee" (("ङी"))) + ("ngei" (("ङै"))) + ("nge" (("ङे"))) + ("ngE" (("ङै"))) + ("ngii" (("ङी"))) + ("ngi" (("ङि"))) + ("ngoo" (("ङू"))) + ("ngou" (("ङे"))) + ("ngo" (("ङो"))) + ("ngO" (("ङौ"))) + ("ngR" (("ङृ"))) + ("nguu" (("ङू"))) + ("ngu" (("ङु"))) + ("ng^" (("ङ्"))) + ("ng" (("ङ्"))) + ("Nii" (("णी"))) + ("nii" (("नी") ("णी"))) + ("Ni" (("णि") ("ण्णि"))) + ("NI" (("णी"))) + ("ni" (("नि") ("णि") ("नै"))) + ("nI" (("नी") ("णी"))) + ("njaa" (("ञा") ("ञ्चा"))) + ("njae" (("ञै") ("ञ्ञै"))) + ("njaH" (("ञः"))) + ("njai" (("ञै") ("ञ्ञै"))) + ("njaM" (("ञँ"))) + ("njau" (("ञौ") ("ञे") ("ञ्ञौ"))) + ("nja" (("ञ") ("ञ्च") ("ञ्ञ"))) + ("njA" (("ञा"))) + ("njee" (("ञी") ("ञ्ची"))) + ("njei" (("ञ्चै") ("ञै") ("ञ्ञै"))) + ("nje" (("ञे") ("ञ्ञे") ("ञ्चे"))) + ("njE" (("ञै") ("ञ्ञै"))) + ("njii" (("ञी"))) + ("njI" (("ञि"))) + ("nji" (("ञि") ("ञ्ञि") ("ञ्चि"))) + ("njoo" (("ञू") ("ञ्ञू"))) + ("njou" (("ञे"))) + ("njo" (("ञो") ("ञ्ञौ") ("ञ्चो"))) + ("njO" (("ञौ") ("ञ्ञौ") ("ञ्चौ"))) + ("njR" (("ञृ"))) + ("njuu" (("ञू") ("ञ्ञू") ("ञ्चू"))) + ("nju" (("ञु") ("ञ्ञु") ("ञ्चु"))) + ("njU" (("ञू"))) + ("nj^" (("ञ्"))) + ("nj" (("ञ्") ("ञ्ञ्"))) + ("Noo" (("णू"))) + ("noo" (("नू") ("णू"))) + ("Nou" (("णे"))) + ("nou" (("नौ"))) + ("No" (("णो") ("नौ"))) + ("NO" (("णौ"))) + ("no" (("नो") ("णो") ("नौ"))) + ("nO" (("नौ"))) + ("NR" (("णृ"))) + ("nR" (("नृ"))) + ("Nuu" (("णू"))) + ("nuu" (("नू") ("णू"))) + ("Nu" (("णु"))) + ("NU" (("णू"))) + ("nu" (("नु") ("णु") ("ण्"))) + ("nU" (("नू") ("णू"))) + ("N^" (("ण्"))) + ("N~" (("ण्"))) + ("N_" (("ण्"))) + ("N" (("ण्") ("ण्") ("ण्ण्") ("न्") ("एन्"))) + ("n^" (("न्"))) + ("n~" (("न्"))) + ("n_" (("न्"))) + ("n" (("न्") ("न्") ("ण्") ("ण्") ("न्न्") ("एन्"))) + ("oo" (("ऊ") ("औ"))) + ("ou" (("औ"))) + ("o" (("ओ"))) + ("O" (("औ"))) + ("@o" (("ॊ"))) + ("paa" (("पा"))) + ("pae" (("पै"))) + ("paH" (("पः"))) + ("pai" (("पै") ("पय्") ("पाय्"))) + ("paM" (("पँ"))) + ("pau" (("पौ") ("पौ"))) + ("pa" (("प"))) + ("Pa" (("प"))) + ("pA" (("पा"))) + ("Pee" (("पि"))) + ("pee" (("पि") ("पै"))) + ("pei" (("पेय्") ("पै"))) + ("pe" (("पे") ("पि"))) + ("pE" (("पै"))) + ("phaa" (("फा"))) + ("phaH" (("फः"))) + ("phai" (("फै"))) + ("phaM" (("फँ"))) + ("phau" (("फौ") ("फे"))) + ("pha" (("फ"))) + ("phA" (("फा"))) + ("phee" (("फि"))) + ("phei" (("फै"))) + ("phe" (("फे"))) + ("phE" (("फै"))) + ("phii" (("फि"))) + ("phi" (("फि"))) + ("phI" (("फी"))) + ("phoo" (("फू"))) + ("phou" (("फे"))) + ("pho" (("फो") ("फौ"))) + ("phO" (("फौ"))) + ("phR" (("फृ"))) + ("phuu" (("फू"))) + ("phu" (("फु"))) + ("phU" (("फू"))) + ("ph^" (("फ्"))) + ("ph" (("फ्") ("पि.एच्."))) + ("pii" (("पि"))) + ("pI" (("पि"))) + ("Pi" (("पि") )) + ("pi" (("पि") ("पै") ("प्पि"))) + ("Poo" (("पू"))) + ("poo" (("पू") ("पौ"))) + ("pou" (("पौ"))) + ("po" (("पो"))) + ("pO" (("पौ"))) + ("pR" (("पृ"))) + ("puu" (("पू"))) + ("pu" (("पु"))) + ("Pu" (("पु"))) + ("pU" (("पू"))) + ("p^" (("प्"))) + ("p" (("प्") ("प्प्") ("पि"))) + ("q" (("क्यु"))) + ("Q" (("क्यू"))) + ("Raa" (("रा"))) + ("raa" (("रा") ("रा"))) + ("rae" (("रै"))) + ("Rae" (("रै"))) + ("raH" (("रः"))) + ("RaH" (("रः"))) + ("rai" (("रै") ("राय्"))) + ("Rai" (("रै") ("राय्"))) + ("raM" (("रँ"))) + ("RaM" (("रँ"))) + ("rau" (("रौ"))) + ("Rau" (("रौ"))) + ("ra" (("र") ("र"))) + ("Ra" (("र") ("र") ("रा"))) + ("rA" (("रा"))) + ("RA" (("रा"))) + ("ree" (("री"))) + ("Ree" (("री") ("री") ("रै"))) + ("rei" (("रै") ("रेय्"))) + ("Rei" (("रै") ("रेय्"))) + ("re" (("रे"))) + ("Re" (("रे"))) + ("rE" (("रै"))) + ("RE" (("रै"))) + ("rii" (("री"))) + ("Rii" (("री"))) + ("rI" (("रि"))) + ("RI" (("रि"))) + ("Ri" (("रि") ("रि"))) + ("ri" (("रि") ("रि") ("रै") ("रै"))) + ("roo" (("रू"))) + ("Roo" (("रू") ("रू"))) + ("rou" (("रौ"))) + ("Rou" (("रौ"))) + ("Ro" (("रो"))) + ("ro" (("रो") ("रौ"))) + ("rO" (("रौ"))) + ("RO" (("रौ"))) + ("rr" (("ऋ"))) + ("RR" (("ऋ"))) + ("rR" (("रृ"))) + ("ruu" (("रू"))) + ("Ruu" (("रू") ("रू"))) + ("ru" (("रु") ("रु"))) + ("Ru" (("रु") ("रु"))) + ("rU" (("रू"))) + ("RU" (("रू"))) + ("r^" (("ऋ"))) + ("r~" (("र्"))) + ("r_" (("र्"))) + ("R^" (("र्"))) + ("R~" (("र्"))) + ("R_" (("र्"))) + ("r" (("र्") ("र्") ("आर"))) + ("R" (("र्") ("र्") ("आर"))) + ("Saa" (("शा") ("सा"))) + ("saa" (("सा") ("शा"))) + ("Sae" (("शै"))) + ("sae" (("सै"))) + ("SaH" (("शः") ("षा"))) + ("saH" (("सः"))) + ("Sai" (("शै") ("सै") ("साय"))) + ("sai" (("सै") ("साय्"))) + ("SaM" (("शँ"))) + ("saM" (("सँ"))) + ("Sau" (("शौ") ("सौ"))) + ("sau" (("सौ") ("से"))) + ("Sa" (("श") ("स"))) + ("SA" (("शा") ("सा"))) + ("sa" (("स") ("श"))) + ("sA" (("सा"))) + ("See" (("शि") ("सि"))) + ("see" (("सी") ("शी"))) + ("Sei" (("शै") ("सि"))) + ("sei" (("सै"))) + ("Se" (("शे") ("से") ("सि"))) + ("SE" (("शै") ("एस.इ."))) + ("se" (("से") ("सि"))) + ("sE" (("सै"))) + ("shaa" (("षा"))) + ("Shaa" (("षा"))) + ("shae" (("षै"))) + ("Shae" (("षै"))) + ("shaH" (("षः"))) + ("ShaH" (("षः"))) + ("shai" (("षै"))) + ("Shai" (("षै"))) + ("shaM" (("षँ"))) + ("ShaM" (("षँ"))) + ("shau" (("षौ") ("षे"))) + ("Shau" (("षौ") ("षौ") ("षे"))) + ("sha" (("ष"))) + ("Sha" (("ष") ("ष") ("षा"))) + ("shA" (("षा"))) + ("ShA" (("षा"))) + ("Shee" (("षी"))) + ("shee" (("षी") ("षी"))) + ("shei" (("षै"))) + ("Shei" (("षै"))) + ("she" (("षे") ("षि"))) + ("She" (("षे") ("षि"))) + ("shE" (("षै"))) + ("ShE" (("षै"))) + ("shii" (("षी"))) + ("Shii" (("षी"))) + ("shi" (("षि"))) + ("Shi" (("षि"))) + ("shI" (("षी"))) + ("ShI" (("षी"))) + ("shoo" (("षू"))) + ("Shoo" (("षू") ("षू"))) + ("shou" (("षे"))) + ("Shou" (("षे"))) + ("Sho" (("षो"))) + ("sho" (("षो") ("षौ"))) + ("shO" (("षौ"))) + ("ShO" (("षौ"))) + ("shR" (("षृ"))) + ("ShR" (("षृ"))) + ("shuu" (("षू"))) + ("Shuu" (("षू"))) + ("shu" (("षु"))) + ("Shu" (("षु") ("षु"))) + ("shU" (("षू"))) + ("ShU" (("षू"))) + ("sh^" (("ष्"))) + ("sh" (("ष्"))) + ("Sh^" (("ष्"))) + ("Sh" (("ष्") ("ष्"))) + ("Sii" (("शि"))) + ("sii" (("सी"))) + ("Si" (("शि") ("सि"))) + ("SI" (("शी") ("एस्.ऐ."))) + ("si" (("सि") ("शि"))) + ("sI" (("सी"))) + ("Soo" (("शू") ("सू"))) + ("soo" (("सू") ("शू"))) + ("Sou" (("शे") ("से"))) + ("sou" (("से"))) + ("So" (("शो") ("सो") ("सौ"))) + ("SO" (("शौ"))) + ("so" (("सो") ("शो") ("सौ"))) + ("sO" (("सौ"))) + ("SR" (("शृ") ("एस.आर"))) + ("sR" (("सृ"))) + ("Suu" (("शू"))) + ("suu" (("सू") ("शू"))) + ("Su" (("शु") ("सु"))) + ("SU" (("शू"))) + ("su" (("सु") ("शु"))) + ("sU" (("सू"))) + ("S^" (("श्"))) + ("S" (("श्") ("स्") ("श्श्") ("एस्"))) + ("s^" (("स्"))) + ("s" (("स्") ("श्") ("स्स्") ("एस्"))) + ("taa" (("टा"))) + ("Taa" (("ठा"))) + ("tae" (("टै"))) + ("Tae" (("ठै"))) + ("taH" (("टः"))) + ("TaH" (("ठः"))) + ("tai" (("टै") ("टाय्"))) + ("Tai" (("ठै"))) + ("taM" (("टँ"))) + ("TaM" (("ठँ"))) + ("tau" (("टौ") ("टे"))) + ("Tau" (("ठौ") ("ठे"))) + ("ta" (("ट") ("र्र") ("ठ"))) + ("tA" (("टा"))) + ("Ta" (("ठ") ("ट") ("त"))) + ("TA" (("ठा"))) + ("tea" (("टी") ("र्रि"))) + ("tee" (("टी") ("र्री"))) + ("Tee" (("ठी"))) + ("tei" (("टै") ("टेय्"))) + ("Tei" (("ठै"))) + ("te" (("टे") ("र्रे") ("ठे"))) + ("tE" (("टै"))) + ("Te" (("ठे") ("टे") ("ते"))) + ("TE" (("ठै"))) + ("thaa" (("ता") ("त्ता"))) + ("Thaa" (("था") ("ता"))) + ("thae" (("तै"))) + ("Thae" (("थै"))) + ("thaH" (("तः"))) + ("ThaH" (("थः"))) + ("thai" (("तै"))) + ("Thai" (("थै") ("तै"))) + ("thaM" (("तँ") ("त्तँ"))) + ("ThaM" (("थँ"))) + ("thau" (("तौ") ("ते"))) + ("Thau" (("थौ") ("थे"))) + ("tha" (("त") ("ध") ("त्त") ("द्ध") ("थ"))) + ("thA" (("ता"))) + ("Tha" (("थ") ("त"))) + ("ThA" (("था"))) + ("thee" (("ती") ("तै"))) + ("Thee" (("थि") ("ति"))) + ("thei" (("तै") ("तेय्"))) + ("Thei" (("थै") ("तेय्"))) + ("the" (("ते"))) + ("thE" (("तै"))) + ("The" (("थे") ("दि") ("ते"))) + ("ThE" (("थै"))) + ("thii" (("ती") ("त्ती"))) + ("Thii" (("थि"))) + ("thi" (("ति") ("त्ति") ("त्थि") ("थि") ("धि") ("द्धि") ("तै"))) + ("thI" (("ती"))) + ("Thi" (("थि") ("ति") ("त्थि"))) + ("ThI" (("थी"))) + ("thoo" (("तू") ("तौ"))) + ("Thoo" (("थू") ("तू"))) + ("thou" (("ते"))) + ("Thou" (("थे"))) + ("tho" (("तो") ("तौ") ("त्तो"))) + ("thO" (("तौ") ("त्तौ"))) + ("Tho" (("थो"))) + ("ThO" (("थौ"))) + ("thR" (("तृ"))) + ("ThR" (("थृ") ("तृ"))) + ("thuu" (("तू"))) + ("Thuu" (("थू") ("तू"))) + ("thu" (("तु") ("त्तु"))) + ("thU" (("तू"))) + ("Thu" (("थु") ("तु"))) + ("ThU" (("थू") ("तू"))) + ("th^" (("त्"))) + ("th" (("त्") ("त्त्"))) + ("Th^" (("थ्"))) + ("Th" (("थ्"))) + ("tii" (("टी"))) + ("Tii" (("ठी"))) + ("ti" (("टि") ("ट्टि") ("र्रि") ("ठि") ("टै"))) + ("tI" (("टी") ("र्री"))) + ("Ti" (("ठि") ("टि") ("ति") ("तै"))) + ("TI" (("ठी"))) + ("too" (("टू") ("र्रू"))) + ("Too" (("ठू") ("टू"))) + ("tou" (("टे"))) + ("Tou" (("ठे"))) + ("to" (("टो") ("टु") ("र्रु"))) + ("tO" (("टौ"))) + ("To" (("ठो") ("टु") ("तो"))) + ("TO" (("ठौ"))) + ("tR" (("टृ"))) + ("TR" (("ठृ"))) + ("TTa" (("ट्ट"))) + ("TTI" (("टि.टि.ऐ."))) + ("TTR" (("टि.टि.आर्."))) + ("TT" (("टि.टि."))) + ("tuu" (("टू") ("र्रू"))) + ("Tuu" (("ठू"))) + ("tu" (("टु") ("र्रु") ("ट्टु"))) + ("tU" (("टू") ("र्रू"))) + ("Tu" (("ठु") ("टु"))) + ("TU" (("ठू"))) + ("t^" (("ट्"))) + ("t" (("ट्") ("ट्ट्") ("र्र्") ("त्") ("टि"))) + ("T^" (("ठ्"))) + ("T" (("ठ्") ("टि"))) + ("uu" (("ऊ"))) + ("u" (("उ") ("ऊ") ("यु"))) + ("U" (("ऊ"))) + ("vaa" (("वा"))) + ("Vaa" (("वा"))) + ("vae" (("वै"))) + ("vaH" (("वः"))) + ("vai" (("वै") ("वय्"))) + ("vaM" (("वँ"))) + ("vau" (("वौ") ("वे"))) + ("va" (("व") ("वा"))) + ("Va" (("व") ("व्व") ("वा"))) + ("vA" (("वा"))) + ("vee" (("वि") ("वै"))) + ("vei" (("वैय्") ("वै"))) + ("ve" (("वे"))) + ("vE" (("वै"))) + ("vii" (("वि"))) + ("vi" (("वि"))) + ("vI" (("वि"))) + ("Vi" (("वि"))) + ("voo" (("वू"))) + ("vou" (("वे"))) + ("vo" (("वो") ("वौ"))) + ("vO" (("वौ"))) + ("vR" (("वृ"))) + ("vuu" (("वू"))) + ("vu" (("वु"))) + ("vU" (("वू"))) + ("V" (("वि"))) + ("v^" (("व्"))) + ("v" (("व्") ("व्व्") ("वि"))) + ("waa" (("वा"))) + ("wae" (("वै"))) + ("waH" (("वः"))) + ("wai" (("वै"))) + ("waM" (("वँ"))) + ("wau" (("वौ"))) + ("wa" (("व"))) + ("wA" (("वा"))) + ("wee" (("वि"))) + ("wei" (("वै"))) + ("we" (("वे"))) + ("wE" (("वै"))) + ("wii" (("वि"))) + ("wi" (("वि"))) + ("wI" (("वि"))) + ("woo" (("वू"))) + ("wou" (("वे"))) + ("wo" (("वो"))) + ("wO" (("वौ"))) + ("wR" (("वृ"))) + ("wuu" (("वू"))) + ("wu" (("वु"))) + ("wU" (("वू"))) + ("w^" (("व्"))) + ("w" (("व्") ("व्व्") ("डब्ल्यू"))) + ("xaa" (("क्षा"))) + ("xaH" (("क्षः"))) + ("xai" (("क्षै"))) + ("xaM" (("क्षँ"))) + ("xau" (("क्षौ") ("क्षे"))) + ("xa" (("क्ष") ("क्स") ("क्से"))) + ("xA" (("क्षा"))) + ("xee" (("क्षी"))) + ("xei" (("क्षै"))) + ("xe" (("क्षे") ("क्षै") ("क्से") ("क्सि") ("क्षि"))) + ("xE" (("क्षै"))) + ("xii" (("क्षी"))) + ("xi" (("क्षि") ("क्सि"))) + ("xI" (("क्षी"))) + ("xoo" (("क्षू"))) + ("xou" (("क्षे"))) + ("xo" (("क्षो"))) + ("xO" (("क्षौ"))) + ("xR" (("क्षृ"))) + ("xuu" (("क्षू"))) + ("xu" (("क्षु") ("क्सु"))) + ("xU" (("क्षू"))) + ("X" (("एक्स्"))) + ("x^" (("क्ष्"))) + ("x" (("क्ष्") ("क्स्") ("एक्स्"))) + ("yaa" (("या"))) + ("Yaa" (("या"))) + ("yae" (("यै"))) + ("yaH" (("यः") ("यः"))) + ("yai" (("यै"))) + ("Yai" (("यै"))) + ("yaM" (("यँ") ("यँ"))) + ("yau" (("यौ") ("ये"))) + ("Yau" (("यौ") ("ये"))) + ("ya" (("य"))) + ("Ya" (("य"))) + ("yA" (("या"))) + ("YA" (("या"))) + ("yei" (("यै"))) + ("Yei" (("यै"))) + ("ye" (("ये") ("यै"))) + ("Ye" (("ये") ("यै"))) + ("yE" (("यै"))) + ("YE" (("यै") ("यै"))) + ("yii" (("यी"))) + ("Yii" (("यी"))) + ("yi" (("यि"))) + ("yI" (("यि"))) + ("Yi" (("यि"))) + ("YI" (("यी"))) + ("yoo" (("यू"))) + ("Yoo" (("यू"))) + ("you" (("ये") ("यू") ("यू") ("ये"))) + ("yo" (("यो"))) + ("Yo" (("यो") ("यौ"))) + ("yO" (("यौ"))) + ("YO" (("यौ"))) + ("yR" (("यृ"))) + ("YR" (("यृ"))) + ("yuu" (("यू"))) + ("Yuu" (("यू"))) + ("yu" (("यु"))) + ("Yu" (("यु"))) + ("yU" (("यू"))) + ("YU" (("यू"))) + ("y^" (("य्"))) + ("y" (("य्") ("य्य्") ("वै"))) + ("Y" (("वै"))) + ("zaa" (("शा") ("सा"))) + ("zaH" (("शः"))) + ("zai" (("शै"))) + ("zaM" (("शँ"))) + ("zau" (("शौ"))) + ("za" (("श") ("स"))) + ("zA" (("शा"))) + ("zee" (("शी") ("सी"))) + ("zei" (("शै"))) + ("ze" (("शे"))) + ("zE" (("शै"))) + ("zhaa" (("षा"))) + ("zhae" (("षै"))) + ("zhaH" (("षः"))) + ("zhai" (("षै"))) + ("zhaM" (("षँ"))) + ("zhau" (("षौ") ("षे"))) + ("zha" (("ष"))) + ("zhA" (("षा"))) + ("zhee" (("षी"))) + ("zhei" (("षै"))) + ("zhe" (("षे"))) + ("zhE" (("षै"))) + ("zhii" (("षी"))) + ("zhi" (("षि"))) + ("zhI" (("षी"))) + ("zhoo" (("षू"))) + ("zhou" (("षे"))) + ("zho" (("षो"))) + ("zhO" (("षौ"))) + ("zhR" (("षृ"))) + ("zhuu" (("षू"))) + ("zhu" (("षु"))) + ("zhU" (("षू"))) + ("zh^" (("ष्"))) + ("zh" (("ष्"))) + ("zii" (("शी"))) + ("zi" (("शि") ("सि"))) + ("zI" (("शी"))) + ("zoo" (("शू") ("सू"))) + ("zou" (("शे"))) + ("zo" (("शो"))) + ("zO" (("शौ"))) + ("zR" (("शृ"))) + ("zuu" (("शू"))) + ("zu" (("शु") ("सु"))) + ("zU" (("शू"))) + ("z^" (("श्"))) + ("z" (("श्") ("स्") ("इसड्"))) +) +) + + + +(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: diff --git a/input-methods/m17n/swanalekha/hi-swanalekha.png b/input-methods/m17n/swanalekha/hi-swanalekha.png Binary files differnew file mode 100755 index 0000000..366d575 --- /dev/null +++ b/input-methods/m17n/swanalekha/hi-swanalekha.png diff --git a/input-methods/m17n/swanalekha/install.sh b/input-methods/m17n/swanalekha/install.sh new file mode 100755 index 0000000..027ea46 --- /dev/null +++ b/input-methods/m17n/swanalekha/install.sh @@ -0,0 +1,4 @@ +#!/bin/sh +cp *.mim /usr/share/m17n/ +cp *.png /usr/share/m17n/icons + diff --git a/input-methods/m17n/swanalekha/kn-swanalekha.mim b/input-methods/m17n/swanalekha/kn-swanalekha.mim new file mode 100755 index 0000000..cd189f3 --- /dev/null +++ b/input-methods/m17n/swanalekha/kn-swanalekha.mim @@ -0,0 +1,1588 @@ +(input-method kn swanalekha) + +(description "Swanalekha Kannada input method") + + +(title "kannada") +(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" (("ಔ"))) + ("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" (("ೇ"))) + ("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" (("ಳ್") ("ಎಲ್") ("ಳ್ಳ್"))) + ("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" (("ಣೃ"))) + ("nt^" (("ನ್ಱ್"))) + ("nt" (("ನ್ಱ್"))) + ("nta" (("ನ್ಱ") ("ಣ್ಟ"))) + ("ntA" (("ನ್ಱಾ"))) + ("ntaa" (("ನ್ಱಾ"))) + ("ntae" (("ನ್ಱೇ"))) + ("ntaH" (("ನ್ಱಃ"))) + ("ntai" (("ನ್ಱೈ"))) + ("ntaM" (("ನ್ಱಂ"))) + ("ntau" (("ನ್ಱ"))) + ("nte" (("ನ್ಱೆ"))) + ("ntE" (("ನ್ಱೇ"))) + ("ntee" (("ನ್ಱೀ"))) + ("ntei" (("ನ್ಱೈ"))) + ("nth^" (("ನ್ತ್"))) + ("nth" (("ನ್ತ್"))) + ("ntha" (("ನ್ತ") ("ನ್ದ"))) + ("nthA" (("ನ್ತಾ"))) + ("nthaa" (("ನ್ತಾ"))) + ("nthaH" (("ನ್ತಃ"))) + ("nthai" (("ನ್ತೈ"))) + ("nthaM" (("ನ್ತಂ"))) + ("nthau" (("ನ್ತ") ("ನ್ತೌ"))) + ("nthe" (("ನ್ತೆ"))) + ("nthE" (("ನ್ತೇ") )) + ("nthee" (("ನ್ತೀ") ("ನ್ದೀ"))) + ("nthei" (("ನ್ತೈ"))) + ("nthi" (("ನ್ತಿ") ("ನ್ದಿ"))) + ("nthI" (("ನ್ತೀ"))) + ("nthii" (("ನ್ತೀ"))) + ("ntho" (("ನ್ತೊ"))) + ("nthO" (("ನ್ತೋ"))) + ("nthoo" (("ನ್ತೂ"))) + ("nthou" (("ನ್ತೌ"))) + ("nthR" (("ನ್ತೃ"))) + ("nthu" (("ನ್ತು"))) + ("nthU" (("ನ್ತೂ"))) + ("nthuu" (("ನ್ತೂ"))) + ("nti" (("ನ್ಱಿ") ("ಣ್ಟಿ"))) + ("ntI" (("ನ್ಱೀ"))) + ("ntii" (("ನ್ಱೀ"))) + ("nto" (("ನ್ಱೊ"))) + ("ntO" (("ನ್ಱೋ"))) + ("ntoo" (("ನ್ಱೂ"))) + ("ntou" (("ನ್ಱೌ"))) + ("ntR" (("ನ್ಱೃ"))) + ("ntu" (("ನ್ಱು"))) + ("ntU" (("ನ್ಱೂ"))) + ("ntuu" (("ನ್ಱೂ"))) + ("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^^" (("ೠ"))) + ("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^" (("ಱ್ಱ್"))) + ("TT" (("ಱ್ಱ್") ("ಟಿ.ಟಿ."))) + ("TTa" (("ಱ್ಱ") ("ಟ್ಟ"))) + ("TTA" (("ಱ್ಱಾ"))) + ("TTaa" (("ಱ್ಱಾ"))) + ("TTah" (("ಱ್ಱಃ"))) + ("TTai" (("ಱ್ಱೈ"))) + ("TTaM" (("ಱ್ಱಂ"))) + ("TTau" (("ಱ್ಱ") ("ಱ್ಱೌ"))) + ("TTe" (("ಱ್ಱೆ"))) + ("TTE" (("ಱ್ಱೇ"))) + ("TTee" (("ಱ್ಱೀ"))) + ("TTei" (("ಱ್ಱೈ"))) + ("TTi" (("ಱ್ಱಿ"))) + ("TTI" (("ಱ್ಱೀ") ("ಟಿ.ಟಿ.ಐ."))) + ("TTii" (("ಱ್ಱೀ"))) + ("TTo" (("ಱ್ಱೊ"))) + ("TTO" (("ಱ್ಱೋ"))) + ("TToo" (("ಱ್ಱೂ"))) + ("TTou" (("ಱ್ಱೌ"))) + ("TTR" (("ಱ್ಱೃ") ("ಟಿ.ಟಿ.ಆರ್."))) + ("TTu" (("ಱ್ಱು"))) + ("TTU" (("ಱ್ಱೂ"))) + ("TTuu" (("ಱ್ಱೂ"))) + ("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" (("ಶೈ"))) + ("zh^" (("್"))) + ("zh" (("್"))) + ("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: + diff --git a/input-methods/m17n/swanalekha/kn-swanalekha.png b/input-methods/m17n/swanalekha/kn-swanalekha.png Binary files differnew file mode 100755 index 0000000..3211505 --- /dev/null +++ b/input-methods/m17n/swanalekha/kn-swanalekha.png diff --git a/input-methods/m17n/swanalekha/ml-swanalekha.mim b/input-methods/m17n/swanalekha/ml-swanalekha.mim index 3c0a15e..ee54db4 100644..100755 --- a/input-methods/m17n/swanalekha/ml-swanalekha.mim +++ b/input-methods/m17n/swanalekha/ml-swanalekha.mim @@ -1,5 +1,5 @@ ;; ml-swanalekha.mim -- m17n version of Swanalekha Malayalam input method -;; Copyright (C) 2007, Santhosh Thottingal <santhosh00@gmail.com>, Swathanthra Malayalam Computing +;; Copyright (C) 2008, Santhosh Thottingal <santhosh.thottingal@gmail.com>, Swathanthra Malayalam Computing ;; This file is part of the m17n database; a sub-part of the m17n ;; library. @@ -22,178 +22,1662 @@ (description "Swanalekha Malayalam input method") -(title "മ") + +(title "സ്വനലേഖ") +(variable + (candidates-group-size)) (map (starter - ("~") ("$") ("^") - ("0") ("1") ("2") ("3") ("4") - ("5") ("6") ("7") ("8") ("9") - ("A") ("B") ("C") ("D") ("E") ("G") ("H") ("I") ("J") ("K") ("L") - ("M") ("N") ("O") ("P") ("R") ("S") ("T") ("U") ("Y") + ("~") ("@") ("^") + ("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")) - (consonant - ("k" "ക്") - ("kh" "ഖ്") - ("K" "ഖ്") - ("g" "ഗ്") - ("gh" "ഘ്") - ("G" "ഘ്") - ("ng" "ങ്") - ("c" "ക്") - ("ch" "ച്") - ("C" "ഛ്") - ("Ch" "ഛ്") - ("j" "ജ്") - ("J" "ഝ്") - ("jh" "ഝ്") - ("nj" "ഞ്") - ("T" "ഠ്") - ("Th" "ഥ്") - ("D" "ഡ്") - ("Dh" "ഢ്") - ("N" "ണ്") - ("t" "ട്") - ("th" "ത്") - ("d" "ദ്") - ("dh" "ധ്") - ("n" "ന്") - ("p" "പ്") - ("P" "ഫ്") - ("ph" "ഫ്") - ("f" "ഫ്") - ("b" "ബ്") - ("B" "ഭ്") - ("bh" "ഭ്") - ("m" "മ്") - ("y" "യ്") - ("r" "ര്") - ("R" "റ്") - ("l" "ല്") - ("L" "ള്") - ("v" "വ്") - ("w" "വ്") - ("S" "ശ്") - ("sh" "ഷ്") - ("Sh" "ശ്") - ("zh" "ഴ്") - ("s" "സ്") - ("h" "ഹ്") - ("TT" "റ്റ്") - ("nk" "ങ്ക്") - ("nt" "ന്റ്") - ("nth" "ന്ത്") - ("nch" "ഞ്ച്") - ("x" "ക്ഷ്") - ("n~" "ന്") - ("l~" "ല്") - ("L~" "ല്") - ("r~" "ര്") - ("R~" "ര്") - ("N~" "ണ്") - ("~" "")) - - (independent - ("a" "അ") - ("aa" "ആ") - ("A" "ആ") - ("i" "ഇ") - ("ii" "ഈ") - ("I" "ഈ") - ("u" "ഉ") - ("oo" "ഊ") - ("U" "ഊ") - ("uu" "ഊ") - ("r^" "ഋ") - ("R^" "ൠ") - ("l^" "ഌ") - ("L^" "ൡ") - ("e" "എ") - ("E" "ഏ") - ("ai" "ഐ") - ("ei" "ഐ") - ("o" "ഒ") - ("O" "ഓ") - ("ou" "ഔ") - ("au" "ഔ") - ("M" "ം") - ("m~" "ം") - ("H" "ഃ") - ("~~" "~") - ("~@" "@") - ("~#" "#") - ("~$" "$") - ("~^" "^") - ("~&" "&") - ("^" "") - ("^^" "") - ("0" "൦") - ("1" "൧") - ("2" "൨") - ("3" "൩") - ("4" "൪") - ("5" "൫") - ("6" "൬") - ("7" "൭") - ("8" "൮") - ("9" "൯")) - - (dependent - ("@" (delete @-) "") - ("#" (delete @-) "") - ("~M" (delete @-) "") - ("a" (delete @-) "") - ("aa" (delete @-) "ാ") - ("A" (delete @-) "ാ") - ("i" (delete @-) "ി") - ("I" (delete @-) "ീ") - ("ii" (delete @-) "ീ") - ("ee" (delete @-) "ീ") - ("u" (delete @-) "ു") - ("U" (delete @-) "ൂ") - ("uu" (delete @-) "ൂ") - ("oo" (delete @-) "ൂ") - ("r^" (delete @-) "ൃ") - ("e" (delete @-) "െ") - ("E" (delete @-) "േ") - ("ai" (delete @-) "ൈ") - ("ei" (delete @-) "ൈ") - ("o" (delete @-) "ൊ") - ("O" (delete @-) "ോ") - ("au" (delete @-) "ൗ") - ("ou" (delete @-) "ൌ") + (map + ("^" (("്"))) + ("~" ((""))) + ("_" ((""))) + ("@A" (("ാ"))) + ("a" (("അ") ("ആ") ("എ"))) + ("A" (("ആ") ("എ"))) + ("@aa" (("ാ"))) + ("aa" (("ആ"))) + ("@ae" (("േ"))) + ("ae" (("ഏ"))) + ("@aH" (("ഃ"))) + ("@ah" (("ഃ"))) + ("aH" (("അഃ"))) + ("@ai" (("ൈ"))) + ("ai" (("ഐ"))) + ("@am" (("ം"))) + ("@aM" (("ം"))) + ("aM" (("അം"))) + ("@au" (("ൗ"))) + ("au" (("ഔ"))) + ("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" (("ഏ") ("ഇ"))) + ("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_" (("ക്"))) + ("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~" (("ല്"))) + ("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~" (("ന്"))) + ("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" (("ങ്ങേ") ("ങേ"))) + ("NgaH" (("ങഃ"))) + ("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" (("ണൃ"))) + ("nt^" (("ന്റ്"))) + ("nt" (("ന്റ്") ("ന്റു്"))) + ("nta" (("ന്റ") ("ണ്ട"))) + ("ntA" (("ന്റാ"))) + ("ntaa" (("ന്റാ"))) + ("ntae" (("ന്റേ"))) + ("ntaH" (("ന്റഃ"))) + ("ntai" (("ന്റൈ"))) + ("ntaM" (("ന്റം"))) + ("ntau" (("ന്റൗ"))) + ("ntE" (("ന്റേ"))) + ("nte" (("ന്റെ"))) + ("ntee" (("ന്റീ"))) + ("ntei" (("ന്റൈ"))) + ("nth^" (("ന്ത്"))) + ("nth" (("ന്ത്") ("ന്തു്"))) + ("ntha" (("ന്ത") ("ന്ദ"))) + ("nthA" (("ന്താ"))) + ("nthaa" (("ന്താ"))) + ("nthaH" (("ന്തഃ"))) + ("nthai" (("ന്തൈ"))) + ("nthaM" (("ന്തം"))) + ("nthau" (("ന്തൗ") ("ന്തൌ"))) + ("nthE" (("ന്തേ") ("ന്ദേ"))) + ("nthe" (("ന്തെ"))) + ("nthee" (("ന്തീ") ("ന്ദീ"))) + ("nthei" (("ന്തൈ"))) + ("nthi" (("ന്തി") ("ന്ദി"))) + ("nthI" (("ന്തീ"))) + ("nthii" (("ന്തീ"))) + ("ntho" (("ന്തൊ"))) + ("nthO" (("ന്തോ"))) + ("nthoo" (("ന്തൂ"))) + ("nthou" (("ന്തൌ"))) + ("nthR" (("ന്തൃ"))) + ("nthu" (("ന്തു"))) + ("nthU" (("ന്തൂ"))) + ("nthuu" (("ന്തൂ"))) + ("nti" (("ന്റി") ("ണ്ടി"))) + ("ntI" (("ന്റീ"))) + ("ntii" (("ന്റീ"))) + ("nto" (("ന്റൊ"))) + ("ntO" (("ന്റോ"))) + ("ntoo" (("ന്റൂ"))) + ("ntou" (("ന്റൌ"))) + ("ntR" (("ന്റൃ"))) + ("ntU" (("ന്റൂ"))) + ("ntu" (("ന്റു"))) + ("ntuu" (("ന്റൂ"))) + ("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^" (("റ്"))) + ("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^" (("ഥ്"))) + ("th" (("ത്") ("തു്") ("ത്ത്") ("ത്തു്"))) + ("tH" (("ഥ്") ("ഥു്"))) + ("Th" (("ഥ്") ("ഥു്"))) + ("TH" (("ഥ്") ("ഥു്"))) + ("tha" (("ത") ("ധ") ("ഥ") ("ത്ത") ("ദ്ധ"))) + ("THa" (("ഥ") ("ത"))) + ("Tha" (("ഥ") ("ത"))) + ("tHa" (("ഠ") ("ത"))) + ("thA" (("താ") ("ഥാ") ("ധാ") ("ത്താ"))) + ("ThA" (("ഥാ"))) + ("tHA" (("ഠാ"))) + ("THA" (("ഥാ"))) + ("thaa" (("താ") ("ഥാ") ("ധാ") ("ത്താ"))) + ("Thaa" (("ഥാ") ("താ"))) + ("THaa" (("ഥാ") ("താ"))) + ("tHaa" (("ഠാ") ("താ"))) + ("tHae" (("ഠേ"))) + ("Thae" (("ഥേ"))) + ("THae" (("ഥേ"))) + ("thae" (("തേ"))) + ("tHaH" (("ഠഃ"))) + ("thaH" (("തഃ"))) + ("ThaH" (("ഥഃ"))) + ("THaH" (("ഥഃ"))) + ("THai" (("ഥൈ") ("തൈ"))) + ("tHai" (("ഠൈ") ("തൈ"))) + ("Thai" (("ഥൈ") ("തൈ"))) + ("thai" (("തൈ"))) + ("thaM" (("തം") ("ത്തം"))) + ("ThaM" (("ഥം"))) + ("tHaM" (("ഠം"))) + ("THaM" (("ഥം"))) + ("Thau" (("ഥൗ") ("ഥൌ"))) + ("tHau" (("ഠൗ") ("ഠൌ"))) + ("THau" (("ഥൗ") ("ഥൌ"))) + ("thau" (("തൗ") ("തൌ"))) + ("THe" (("ഥെ") ("ദി") ("തെ"))) + ("tHe" (("ഠെ") ("ദി") ("തെ"))) + ("The" (("ഥെ") ("ദി") ("തെ"))) + ("tHE" (("ഠേ"))) + ("ThE" (("ഥേ"))) + ("the" (("തെ"))) + ("THE" (("ഥേ"))) + ("thE" (("തേ"))) + ("thee" (("തീ") ("ഥീ") ("തേ"))) + ("Thee" (("ഥീ") ("തീ"))) + ("tHee" (("ഠീ") ("തീ"))) + ("THee" (("ഥീ") ("തീ"))) + ("Thei" (("ഥൈ") ("തെയ്"))) + ("thei" (("തൈ") ("തെയ്"))) + ("tHei" (("ഠൈ") ("തെയ്"))) + ("THei" (("ഥൈ") ("തെയ്"))) + ("THi" (("ഥി") ("തി") ("ത്ഥി"))) + ("Thi" (("ഥി") ("തി") ("ത്ഥി"))) + ("tHi" (("ഠി") ("തി") ("ത്ഠി"))) + ("thi" (("തി") ("ത്തി") ("ഥി") ("ധി") ("ത്ഥി") ("ദ്ധി") ("തൈ"))) + ("THI" (("ഥീ"))) + ("ThI" (("ഥീ"))) + ("tHI" (("ഠീ"))) + ("thI" (("തീ"))) + ("thii" (("തീ") ("ത്തീ") ("ഥീ") ("ധീ"))) + ("THii" (("ഥീ"))) + ("Thii" (("ഥീ"))) + ("tHii" (("ഠീ"))) + ("tho" (("തൊ") ("തോ") ("ത്തൊ"))) + ("thO" (("തോ") ("ത്തോ"))) + ("tHo" (("ഠൊ"))) + ("Tho" (("ഥൊ"))) + ("ThO" (("ഥോ"))) + ("THO" (("ഥോ"))) + ("THo" (("ഥൊ"))) + ("tHO" (("ഠോ"))) + ("thoo" (("തൂ") ("ഥൂ") ("തോ"))) + ("tHoo" (("ഥൂ") ("തൂ"))) + ("THoo" (("ഥൂ") ("തൂ"))) + ("Thoo" (("ഥൂ") ("തൂ"))) + ("Thou" (("ഥൌ"))) + ("THou" (("ഥൌ"))) + ("thou" (("തൌ"))) + ("tHou" (("ഠൌ"))) + ("THR" (("ഥൃ") ("തൃ"))) + ("ThR" (("ഥൃ") ("തൃ"))) + ("tHR" (("ഥൃ") ("തൃ"))) + ("thR" (("തൃ"))) + ("THU" (("ഥൂ") ("തൂ"))) + ("tHu" (("ഥു") ("തു"))) + ("ThU" (("ഥൂ") ("തൂ"))) + ("tHU" (("ഥൂ") ("തൂ"))) + ("Thu" (("ഥു") ("തു"))) + ("THu" (("ഥു") ("തു"))) + ("thu" (("തു") ("ത്തു"))) + ("thU" (("തൂ"))) + ("thuu" (("തൂ") ("ഥൂ"))) + ("tHuu" (("ഥൂ") ("തൂ"))) + ("Thuu" (("ഥൂ") ("തൂ"))) + ("THuu" (("ഥൂ") ("തൂ"))) + ("Ti" (("ഠി") ("ടി") ("തി") ("തൈ"))) + ("ti" (("ടി") ("തി") ("ട്ടി") ("റ്റി") ("ഠി") ("ടൈ") ("തൈ"))) + ("tI" (("ടീ") ("റ്റീ"))) + ("TI" (("ഠീ"))) + ("tii" (("ടീ"))) + ("Tii" (("ഠീ"))) + ("To" (("ഠൊ") ("ടു") ("തൊ"))) + ("to" (("ടൊ") ("ടു") ("റ്റു"))) + ("TO" (("ഠോ") ("തോ"))) + ("tO" (("ടോ"))) + ("Too" (("ഠൂ") ("ടൂ") ("തൂ"))) + ("too" (("ടൂ") ("റ്റൂ") ("തൂ"))) + ("Tou" (("ഠൌ"))) + ("tou" (("ടൌ"))) + ("TR" (("ഠൃ"))) + ("tR" (("ടൃ"))) + ("TT^" (("റ്റ്"))) + ("TT" (("റ്റ്") ("റ്റു്") ("ടി.ടി."))) + ("TTa" (("റ്റ") ("ട്ട"))) + ("TTA" (("റ്റാ"))) + ("TTaa" (("റ്റാ"))) + ("TTah" (("റ്റഃ"))) + ("TTai" (("റ്റൈ"))) + ("TTaM" (("റ്റം"))) + ("TTau" (("റ്റൗ") ("റ്റൌ"))) + ("TTe" (("റ്റെ"))) + ("TTE" (("റ്റേ"))) + ("TTee" (("റ്റീ"))) + ("TTei" (("റ്റൈ"))) + ("TTI" (("റ്റീ") ("ടി.ടി.ഐ."))) + ("TTi" (("റ്റി"))) + ("TTii" (("റ്റീ"))) + ("TTO" (("റ്റോ"))) + ("TTo" (("റ്റൊ"))) + ("TToo" (("റ്റൂ"))) + ("TTou" (("റ്റൌ"))) + ("TTR" (("റ്റൃ") ("ടി.ടി.ആര്."))) + ("TTu" (("റ്റു"))) + ("TTU" (("റ്റൂ"))) + ("TTuu" (("റ്റൂ"))) + ("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" (("യേ"))) + ("Yee" (("യീ"))) + ("yee" (("യീ"))) + ("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" (("ശൈ"))) + ("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" (("ശൂ"))) + + ) ) - (return - ((Return))) + + +(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) (undo)))) + ((BackSpace))) + + (commit-preedit + ((S-\ )))) + (state + ;; When an initial character is typed, re-handle it in "main" state. (init - (starter (pushback 1) (shift intermediate))) - - (intermediate - (consonant (shift second)) - (independent (shift finish)) - (backspace) - (return (shift init))) + (starter (show) (pushback 1) (shift main))) - (second - (consonant) - (dependent (shift finish)) - (backspace) - (return (shift init))) + (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)))) + - (finish - (return) - (t (shift init)))) +(state + (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: -;; coding: utf-8 ;; mode: lisp +;; coding: utf-8 ;; End: diff --git a/input-methods/m17n/swanalekha/ml-swanalekha.png b/input-methods/m17n/swanalekha/ml-swanalekha.png Binary files differnew file mode 100755 index 0000000..0bb807c --- /dev/null +++ b/input-methods/m17n/swanalekha/ml-swanalekha.png diff --git a/input-methods/m17n/swanalekha/mr-swanalekha.mim b/input-methods/m17n/swanalekha/mr-swanalekha.mim new file mode 100755 index 0000000..82135cf --- /dev/null +++ b/input-methods/m17n/swanalekha/mr-swanalekha.mim @@ -0,0 +1,1344 @@ +(input-method mr swanalekha) + +(description "Swanalekha Marathi input method") + + +(title "marathi") +(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 + ("~" ((""))) + ("_" ((""))) + ("aa" (("आ"))) + ("@aa" (("ा"))) + ("ae" (("ऎ"))) + ("aH" (("अः"))) + ("@ah" (("ः"))) + ("@aH" (("ः"))) + ("ai" (("ऐ"))) + ("aM" (("अँ"))) + ("au" (("औ"))) + ("a" (("अ") ("आ") ("ए"))) + ("A" (("आ") ("ए"))) + ("baa" (("बा"))) + ("Baa" (("भा") ("बा"))) + ("bae" (("बै"))) + ("baH" (("बः"))) + ("BaH" (("भः"))) + ("bai" (("बै") ("बाय्"))) + ("Bai" (("भै"))) + ("baM" (("बँ"))) + ("BaM" (("भँ"))) + ("bau" (("बौ") ("बौ") ("भौ"))) + ("Bau" (("भौ") ("भे"))) + ("ba" (("ब"))) + ("bA" (("बा"))) + ("Ba" (("भ") ("ब") ("बा"))) + ("BA" (("भा") ("बि.ए."))) + ("bee" (("बी"))) + ("Bee" (("भी"))) + ("bei" (("बै"))) + ("Bei" (("भै"))) + ("be" (("बे"))) + ("bE" (("बै"))) + ("Be" (("भे"))) + ("BE" (("भै"))) + ("bhaa" (("भा"))) + ("bhae" (("भै"))) + ("bhaH" (("भः"))) + ("bhai" (("भै") ("भाय्"))) + ("bhaM" (("भँ"))) + ("bhau" (("भौ") ("भे"))) + ("bha" (("भ"))) + ("bhA" (("भा"))) + ("bhee" (("भी"))) + ("bhei" (("भै"))) + ("bhe" (("भे"))) + ("bhE" (("भै"))) + ("bhii" (("भी"))) + ("bhi" (("भि"))) + ("bhI" (("भि"))) + ("bhoo" (("भू"))) + ("bhou" (("भे"))) + ("bho" (("भो"))) + ("bhO" (("भौ"))) + ("bhR" (("भृ"))) + ("bhuu" (("भू"))) + ("bhu" (("भु"))) + ("bhU" (("भू"))) + ("bh^" (("भ्"))) + ("bh" (("भ्"))) + ("bii" (("बी"))) + ("Bii" (("भी"))) + ("bi" (("बि") ("बै"))) + ("bI" (("बी"))) + ("Bi" (("भि") ("बै"))) + ("BI" (("भी"))) + ("boo" (("बू") ("बौ"))) + ("Boo" (("भू"))) + ("bou" (("बौ"))) + ("Bou" (("भे"))) + ("bo" (("बो"))) + ("bO" (("बौ"))) + ("Bo" (("भो") ("बौ"))) + ("BO" (("भौ"))) + ("bR" (("बृ"))) + ("BR" (("भृ"))) + ("buu" (("बू"))) + ("Buu" (("भू"))) + ("bu" (("बु"))) + ("bU" (("बू"))) + ("Bu" (("भु") ("बु"))) + ("BU" (("भू"))) + ("b^" (("ब्"))) + ("b" (("ब्") ("ब्ब्") ("बि"))) + ("B^" (("भ्"))) + ("B" (("भ्") ("ब्") ("बि"))) + ("caa" (("का"))) + ("cae" (("कै"))) + ("cai" (("कै"))) + ("cau" (("कौ"))) + ("ca" (("क") ("का") ("कै"))) + ("cA" (("का"))) + ("cee" (("कि"))) + ("cei" (("कै"))) + ("ce" (("के") ("स्"))) + ("cE" (("कै"))) + ("chaa" (("चा"))) + ("Chaa" (("छा"))) + ("chae" (("चै"))) + ("Chae" (("छै"))) + ("chaH" (("चः"))) + ("ChaH" (("छः"))) + ("chai" (("चै") ("चाय्"))) + ("Chai" (("छै"))) + ("chaM" (("चँ"))) + ("ChaM" (("छँ"))) + ("chau" (("चौ"))) + ("Chau" (("छौ") ("छे"))) + ("cha" (("च") ("च्च") ("च्छ"))) + ("chA" (("चा"))) + ("Cha" (("छ") ("च") ("च्च"))) + ("ChA" (("छा"))) + ("chee" (("ची") ("च्ची"))) + ("Chee" (("छी"))) + ("chei" (("चै"))) + ("Chei" (("छै"))) + ("che" (("चे") ("च्चे"))) + ("chE" (("चै"))) + ("Che" (("छे"))) + ("ChE" (("छै"))) + ("chhaa" (("छा"))) + ("chhae" (("छै"))) + ("chhaH" (("छः"))) + ("chhai" (("छै"))) + ("chhaM" (("छँ"))) + ("chhau" (("छौ") ("छे"))) + ("chha" (("छ") ("च्च"))) + ("chhA" (("छा"))) + ("chhee" (("छी"))) + ("chhei" (("छै"))) + ("chhe" (("छे"))) + ("chhE" (("छै"))) + ("chhii" (("छी"))) + ("chhI" (("छि"))) + ("chhi" (("छी"))) + ("chhoo" (("छू"))) + ("chhou" (("छे"))) + ("chho" (("छो"))) + ("chhO" (("छौ"))) + ("chhR" (("छृ"))) + ("chhuu" (("छू"))) + ("chhu" (("छु"))) + ("chhU" (("छू"))) + ("chh^" (("छ्"))) + ("chh" (("छ्"))) + ("chii" (("ची"))) + ("Chii" (("छी"))) + ("chi" (("चि") ("च्चि") ("चै"))) + ("chI" (("ची"))) + ("Chi" (("छि") ("चि"))) + ("ChI" (("छी"))) + ("choo" (("चू") ("च्चू") ("चौ"))) + ("Choo" (("छू"))) + ("chou" (("चे"))) + ("Chou" (("छे"))) + ("cho" (("चो") ("चौ"))) + ("chO" (("चौ"))) + ("Cho" (("छो"))) + ("ChO" (("छौ"))) + ("chR" (("चृ"))) + ("ChR" (("छृ"))) + ("chuu" (("चू") ("च्चू"))) + ("Chuu" (("छू"))) + ("chu" (("चु") ("च्यु"))) + ("chU" (("चू"))) + ("Chu" (("छु") ("चु"))) + ("ChU" (("छू"))) + ("ch^" (("च्"))) + ("ch" (("च्") ("च्च्") ("क्क्"))) + ("Ch^" (("छ्"))) + ("Ch" (("छ्"))) + ("ci" (("कि") ("सि") ("सै"))) + ("cI" (("की"))) + ("cka" (("क"))) + ("ck" (("क्क्"))) + ("coo" (("कू"))) + ("cou" (("के"))) + ("co" (("को"))) + ("cO" (("को"))) + ("cR" (("कृ"))) + ("cuu" (("कू"))) + ("cu" (("कु"))) + ("cU" (("कू"))) + ("c" (("क्") ("सि"))) + ("C" (("सि"))) + ("Daa" (("डा"))) + ("daa" (("दा") ("टा"))) + ("Dae" (("डै"))) + ("dae" (("दै"))) + ("DaH" (("डः"))) + ("daH" (("दः"))) + ("Dai" (("डै"))) + ("dai" (("दै") ("डाय्"))) + ("DaM" (("डँ"))) + ("daM" (("दँ"))) + ("Dau" (("डौ") ("डे"))) + ("dau" (("दौ") ("दे"))) + ("Da" (("ड") ("द") ("ठ"))) + ("DA" (("डा"))) + ("da" (("द") ("ट") ("ड"))) + ("dA" (("दा") ("टा"))) + ("Dee" (("डी"))) + ("dee" (("दी") ("टी"))) + ("Dei" (("डै"))) + ("dei" (("दै") ("डैय्"))) + ("De" (("डे") ("टे"))) + ("DE" (("डै"))) + ("de" (("दे") ("टे") ("ते"))) + ("dE" (("दै") ("तै"))) + ("Dhaa" (("ढा"))) + ("dhaa" (("धा"))) + ("Dhae" (("ढै"))) + ("dhae" (("धै"))) + ("DhaH" (("ढः"))) + ("dhaH" (("धः"))) + ("Dhai" (("ढै"))) + ("dhai" (("धै"))) + ("DhaM" (("ढँ"))) + ("dhaM" (("धँ"))) + ("Dhau" (("ढौ") ("ढे"))) + ("dhau" (("धौ") ("धे"))) + ("Dha" (("ढ"))) + ("DhA" (("ढा"))) + ("dha" (("ध"))) + ("dhA" (("धा"))) + ("Dhee" (("ढी"))) + ("dhee" (("धि"))) + ("Dhei" (("ढै"))) + ("dhei" (("धै"))) + ("Dhe" (("ढे"))) + ("DhE" (("ढै"))) + ("dhe" (("धे"))) + ("dhE" (("धै"))) + ("Dhii" (("ढी"))) + ("dhii" (("धि"))) + ("Dhi" (("ढि"))) + ("DhI" (("ढी"))) + ("dhi" (("धि"))) + ("dhI" (("धि"))) + ("Dhoo" (("ढू"))) + ("dhoo" (("धू"))) + ("Dhou" (("ढे"))) + ("dhou" (("धे"))) + ("Dho" (("ढो"))) + ("DhO" (("ढौ"))) + ("dho" (("धो"))) + ("dhO" (("धौ"))) + ("DhR" (("ढृ"))) + ("dhR" (("धृ"))) + ("Dhuu" (("ढू"))) + ("dhuu" (("धू"))) + ("Dhu" (("ढु"))) + ("DhU" (("ढू"))) + ("dhu" (("धु"))) + ("dhU" (("धू"))) + ("Dh^" (("ढ्"))) + ("Dh" (("ढ्"))) + ("dh^" (("ध्"))) + ("dh" (("ध्"))) + ("Dii" (("डी"))) + ("dii" (("दी") ("टी"))) + ("Di" (("डि"))) + ("DI" (("डी"))) + ("dI" (("दि") ("टि"))) + ("di" (("दि") ("टि") ("धि") ("थि") ("डै"))) + ("Doo" (("डू"))) + ("doo" (("दू"))) + ("Dou" (("डे"))) + ("dou" (("दे"))) + ("Do" (("डो"))) + ("DO" (("डौ"))) + ("do" (("दो"))) + ("dO" (("दौ"))) + ("DR" (("डृ"))) + ("dR" (("दृ"))) + ("Duu" (("डू"))) + ("duu" (("दू"))) + ("Du" (("डु") ("दु"))) + ("DU" (("डू"))) + ("du" (("दु") ("टु") ("दुः"))) + ("dU" (("दू"))) + ("D^" (("ड्"))) + ("D" (("ड्") ("द्") ("डि"))) + ("d^" (("द्"))) + ("d" (("द्") ("ट्") ("डि") ("द्द्"))) + ("ee" (("ई"))) + ("ei" (("ऐ"))) + ("E" (("ऎ") ("इ"))) + ("e" (("ए") ("इ"))) + ("faa" (("फा"))) + ("faH" (("फः"))) + ("fai" (("फै"))) + ("faM" (("फँ"))) + ("fau" (("फौ") ("फे"))) + ("fa" (("फ"))) + ("fA" (("फा"))) + ("fee" (("फी"))) + ("fei" (("फै"))) + ("fe" (("फे"))) + ("fE" (("फै"))) + ("fii" (("फी"))) + ("fi" (("फि"))) + ("fI" (("फी"))) + ("foo" (("फू"))) + ("fou" (("फे"))) + ("fo" (("फो"))) + ("fO" (("फौ"))) + ("fR" (("फृ"))) + ("fuu" (("फू"))) + ("fu" (("फु"))) + ("fU" (("फू"))) + ("f^" (("फ्"))) + ("f" (("फ्") ("एफ्"))) + ("gaa" (("गा"))) + ("Gaa" (("घा") ("ग्गा"))) + ("gae" (("गै"))) + ("Gae" (("घै") ("ग्गै"))) + ("gaH" (("गः"))) + ("GaH" (("घः"))) + ("gai" (("गै"))) + ("Gai" (("घै") ("गय्") ("गेय्") ("ग्गै"))) + ("gaM" (("गँ"))) + ("GaM" (("घँ"))) + ("gau" (("गौ") ("गे"))) + ("Gau" (("घौ") ("गौ") ("घे"))) + ("ga" (("ग") ("ज") ("क") ("ख"))) + ("gA" (("गा"))) + ("Ga" (("घ") ("ग") ("ग्ग") ("ज"))) + ("GA" (("घा") ("ग्गा"))) + ("gee" (("गी"))) + ("Gee" (("घि") ("ग्गि"))) + ("gei" (("गै"))) + ("Gei" (("घै") ("ग्गै"))) + ("ge" (("गे"))) + ("gE" (("गै"))) + ("Ge" (("घे") ("गे") ("ग्गे") ("जे"))) + ("GE" (("घै") ("ग्गै"))) + ("ghaa" (("घा"))) + ("ghae" (("घै"))) + ("ghaH" (("घः"))) + ("ghai" (("घै"))) + ("ghaM" (("घँ"))) + ("ghau" (("घौ"))) + ("gha" (("घ") ("ख"))) + ("ghA" (("घा"))) + ("ghee" (("घि"))) + ("ghei" (("घै"))) + ("ghe" (("घे"))) + ("ghE" (("घै"))) + ("ghii" (("घि"))) + ("ghi" (("घि"))) + ("ghI" (("घि"))) + ("ghoo" (("घू"))) + ("ghou" (("घे"))) + ("gho" (("घो"))) + ("ghO" (("घौ"))) + ("ghR" (("घृ"))) + ("ghuu" (("घू"))) + ("ghu" (("घु"))) + ("ghU" (("घू"))) + ("gh^" (("घ्"))) + ("gh" (("घ्"))) + ("gii" (("गी"))) + ("Gii" (("घी") ("ग्गी"))) + ("gi" (("गि") ("कि") ("जि"))) + ("gI" (("गी"))) + ("GI" (("घि") ("ग्गि") ("ग्गि"))) + ("Gi" (("घि") ("ग्गी"))) + ("goo" (("गू") ("गौ"))) + ("Goo" (("घू") ("ग्गू") ("घौ") ("ग्गौ"))) + ("gou" (("गे"))) + ("Gou" (("घे"))) + ("go" (("गो") ("गौ"))) + ("gO" (("गौ"))) + ("Go" (("घो") ("गौ") ("गो") ("ग्गो"))) + ("GO" (("घौ"))) + ("gR" (("गृ"))) + ("GR" (("घृ") ("ग्गृ"))) + ("guu" (("गू"))) + ("Guu" (("घू") ("ग्गू"))) + ("gu" (("गु"))) + ("gU" (("गू"))) + ("Gu" (("घु") ("गु") ("ग्गु"))) + ("GU" (("घू") ("ग्गू"))) + ("g^" (("ग्"))) + ("g" (("ग्") ("जि"))) + ("G^" (("घ्"))) + ("G" (("घ्") ("जि") ("ग्गि"))) + ("haa" (("हा"))) + ("haH" (("हः"))) + ("hai" (("है") ("हाय्"))) + ("haM" (("हँ"))) + ("hau" (("हौ"))) + ("ha" (("ह") ("हा"))) + ("hA" (("हा"))) + ("hee" (("ही"))) + ("hei" (("है") ("हैय्"))) + ("he" (("हे") ("हि"))) + ("hE" (("है"))) + ("hii" (("ही"))) + ("hi" (("हि") ("हाय्"))) + ("hI" (("ही"))) + ("hoo" (("हू"))) + ("hou" (("हौ"))) + ("ho" (("हो") ("हौ"))) + ("hO" (("हौ"))) + ("hR" (("हृ"))) + ("huu" (("हू"))) + ("hu" (("हु"))) + ("hU" (("हू"))) + ("H" (("एच्च्"))) + ("h^" (("ह्"))) + ("h" (("ह्") ("एच्") ("एच्च्"))) + ("ii" (("ई"))) + ("@ii" (("ी"))) + ("i" (("इ") ("ई") ("ऐ"))) + ("I" (("ई") ("ऐ"))) + ("jaa" (("जा"))) + ("Jaa" (("झा"))) + ("jae" (("जै"))) + ("Jae" (("झै"))) + ("jaH" (("जः"))) + ("JaH" (("झः"))) + ("jai" (("जै") ("जय्"))) + ("Jai" (("झै") ("जय्"))) + ("jaM" (("जँ"))) + ("JaM" (("झँ"))) + ("jau" (("जौ") ("जे"))) + ("Jau" (("झौ") ("झे"))) + ("ja" (("ज") ("जे"))) + ("jA" (("जा"))) + ("Ja" (("झ") ("ज") ("जे"))) + ("JA" (("झा"))) + ("jee" (("जी"))) + ("Jee" (("झी") ("जी"))) + ("jei" (("जै"))) + ("Jei" (("झै"))) + ("je" (("जे") ("जि"))) + ("jE" (("जै"))) + ("Je" (("झे"))) + ("JE" (("झै"))) + ("jhaa" (("झा"))) + ("jhae" (("झै"))) + ("jhaH" (("झः"))) + ("jhai" (("झै"))) + ("jhaM" (("झँ"))) + ("jhau" (("झौ") ("झे"))) + ("jha" (("झ"))) + ("jhA" (("झा"))) + ("jhee" (("झि"))) + ("jhei" (("झै"))) + ("jhe" (("झे"))) + ("jhE" (("झै"))) + ("jhii" (("झि"))) + ("jhi" (("झि"))) + ("jhI" (("झि"))) + ("jhoo" (("झू") ("झौ"))) + ("jhou" (("झे"))) + ("jho" (("झो"))) + ("jhO" (("झौ"))) + ("jhR" (("झृ"))) + ("jhuu" (("झू"))) + ("jhu" (("झु"))) + ("jhU" (("झू"))) + ("jh^" (("झ्"))) + ("jh" (("झ्"))) + ("jii" (("जी"))) + ("Jii" (("झी"))) + ("jI" (("जि"))) + ("ji" (("जि") ("जै"))) + ("Ji" (("झि") ("जि") ("जै"))) + ("JI" (("झी"))) + ("joo" (("जू"))) + ("Joo" (("झू") ("जू") ("झौ"))) + ("jou" (("जे"))) + ("Jou" (("झे"))) + ("jo" (("जो"))) + ("jO" (("जौ"))) + ("Jo" (("झो") ("जौ") ("जो"))) + ("JO" (("झौ"))) + ("jR" (("जृ"))) + ("JR" (("झृ") ("जे.आर्"))) + ("juu" (("जू"))) + ("Juu" (("झू") ("जू"))) + ("ju" (("जु"))) + ("jU" (("जू"))) + ("Ju" (("झु") ("जु"))) + ("JU" (("झू") ("जे.यु."))) + ("j^" (("ज्"))) + ("j" (("ज्") ("जे"))) + ("J" (("झ्") ("जे"))) + ("kaa" (("का") ("गा"))) + ("Kaa" (("खा"))) + ("kae" (("कै"))) + ("Kae" (("खै"))) + ("kaH" (("कः"))) + ("KaH" (("खः"))) + ("kai" (("कै") ("कय्"))) + ("Kai" (("खै"))) + ("kaM" (("कँ"))) + ("KaM" (("खँ"))) + ("kau" (("कौ") ("के"))) + ("Kau" (("खौ"))) + ("ka" (("क") ("ग") ("ख") ("घ"))) + ("kA" (("का"))) + ("Ka" (("ख") ("क") ("क्क"))) + ("KA" (("खा"))) + ("kee" (("की"))) + ("Kee" (("खि") ("कि"))) + ("kei" (("कै") ("केय्"))) + ("Kei" (("खै"))) + ("ke" (("के"))) + ("kE" (("कै"))) + ("Ke" (("खे") ("के"))) + ("KE" (("खै"))) + ("khaa" (("खा"))) + ("khae" (("खै"))) + ("khaH" (("खः"))) + ("khai" (("खै"))) + ("khaM" (("खँ"))) + ("khau" (("खौ") ("खे"))) + ("kha" (("ख") ("क्क") ("घ"))) + ("khA" (("खा"))) + ("khee" (("खि"))) + ("khei" (("खै"))) + ("khe" (("खे"))) + ("khE" (("खै"))) + ("khii" (("खि"))) + ("khI" (("खि"))) + ("khi" (("खि") ("क्कि"))) + ("khoo" (("खू"))) + ("khou" (("खे"))) + ("kho" (("खो"))) + ("khO" (("खौ"))) + ("khR" (("खृ"))) + ("khuu" (("खू"))) + ("khu" (("खु") ("घु"))) + ("khU" (("खू"))) + ("kh^" (("ख्"))) + ("kh" (("ख्") ("घ्"))) + ("Kii" (("खि"))) + ("ki" (("कि") ("गि") ("घि") ("खि") ("कै"))) + ("KI" (("ख"))) + ("Ki" (("खि") ("कि"))) + ("koo" (("कू") ("क"))) + ("Koo" (("खू") ("कू") ("कौ"))) + ("kou" (("के"))) + ("Kou" (("खे"))) + ("ko" (("को"))) + ("kO" (("को"))) + ("Ko" (("खो") ("को") ("कौ"))) + ("KO" (("खौ"))) + ("kR" (("कृ"))) + ("KR" (("खृ"))) + ("kuu" (("कू"))) + ("Kuu" (("खू") ("कू"))) + ("ku" (("कु") ("कू"))) + ("kU" (("कू"))) + ("Ku" (("खु") ("कु"))) + ("KU" (("खू"))) + ("k^" (("क्"))) + ("k" (("क्") ("क्क्") ("के"))) + ("K^" (("ख्"))) + ("K" (("ख्") ("के"))) + ("laa" (("ला") ("ला"))) + ("Laa" (("ला") ("ला"))) + ("lae" (("लै"))) + ("Lae" (("लै") ("लै"))) + ("laH" (("लः"))) + ("LaH" (("लः"))) + ("lai" (("लै"))) + ("Lai" (("लै"))) + ("laM" (("लँ"))) + ("LaM" (("लँ"))) + ("lau" (("लौ"))) + ("Lau" (("लौ") ("लौ") ("ले"))) + ("la" (("ल") ("ल"))) + ("La" (("ल") ("ल"))) + ("lA" (("ला"))) + ("LA" (("ला"))) + ("lee" (("ली") ("ली"))) + ("Lee" (("ली") ("ली"))) + ("lei" (("लै"))) + ("Lei" (("लै"))) + ("le" (("ले") ("ले"))) + ("Le" (("ले") ("ले"))) + ("lE" (("लै"))) + ("LE" (("लै") ("लै"))) + ("lii" (("ली"))) + ("Lii" (("ली"))) + ("Li" (("लि") ("लि"))) + ("li" (("लि") ("लि") ("लै") ("लै"))) + ("lI" (("ली"))) + ("LI" (("ली"))) + ("Loo" (("लू") ("लू"))) + ("loo" (("लू") ("लौ"))) + ("lou" (("ले"))) + ("Lou" (("ले"))) + ("lo" (("लो") ("लौ"))) + ("Lo" (("लो") ("लौ") ("लो"))) + ("lO" (("लौ"))) + ("LO" (("लौ"))) + ("lR" (("लृ"))) + ("LR" (("लृ"))) + ("luu" (("लू"))) + ("Luu" (("लू") ("लू"))) + ("lu" (("लु") ("लु"))) + ("Lu" (("लु") ("लु"))) + ("lU" (("लू"))) + ("LU" (("लू"))) + ("l^" (("ल्"))) + ("l~" (("ल्"))) + ("l_" (("ल्"))) + ("L^" (("ल्"))) + ("L~" (("ल्"))) + ("L_" (("ल्"))) + ("L" (("ल्") ("ल्") ("एल्") ("ल्ल्"))) + ("l" (("ल्") ("ल्") ("ल्") ("एल्"))) + ("maa" (("मा"))) + ("mae" (("मै"))) + ("maH" (("मः"))) + ("mai" (("मै") ("मय्"))) + ("maM" (("मँ"))) + ("mau" (("मौ") ("मे"))) + ("ma" (("म") ("म्म"))) + ("mA" (("मा"))) + ("mee" (("मी"))) + ("mei" (("मेय्") ("मै"))) + ("me" (("मे"))) + ("mE" (("मै"))) + ("mii" (("मी"))) + ("mi" (("मि"))) + ("mI" (("मि"))) + ("moo" (("मू") ("मौ"))) + ("mou" (("मे"))) + ("mo" (("मो") ("मौ"))) + ("mO" (("मौ"))) + ("mR" (("मृ"))) + ("muu" (("मू"))) + ("mu" (("मु"))) + ("mU" (("मू"))) + ("m^" (("म्"))) + ("m" (("म्") )) + ("m~" (("ँ"))) + ("m_" (("ँ"))) + ("Naa" (("णा") ("ना"))) + ("naa" (("ना") ("णा"))) + ("Nae" (("णै"))) + ("nae" (("नै"))) + ("NaH" (("णः"))) + ("naH" (("नः"))) + ("Nai" (("णै"))) + ("nai" (("नै") ("नाय्"))) + ("NaM" (("णँ"))) + ("naM" (("नँ"))) + ("Nau" (("णौ") ("णे"))) + ("nau" (("नौ") ("नौ"))) + ("Na" (("ण") ("न") ("ना") ("ण्ण"))) + ("NA" (("णा"))) + ("na" (("न") ("ण"))) + ("nA" (("ना"))) + ("Nee" (("णी") ("णै") ("नि"))) + ("nee" (("नी"))) + ("Nei" (("णै"))) + ("nei" (("नेय्") ("नै"))) + ("Ne" (("णे"))) + ("NE" (("णै"))) + ("ne" (("ने") ("न्") ("ण्"))) + ("nE" (("नै"))) + ("ngaa" (("ङा"))) + ("ngai" (("ङै"))) + ("ngaM" (("ङँ"))) + ("ngau" (("ङौ"))) + ("nga" (("ङ") ("ङ्ङ"))) + ("ngA" (("ङा"))) + ("ngee" (("ङी"))) + ("ngei" (("ङै"))) + ("nge" (("ङे"))) + ("ngE" (("ङै"))) + ("ngii" (("ङी"))) + ("ngi" (("ङि"))) + ("ngoo" (("ङू"))) + ("ngou" (("ङे"))) + ("ngo" (("ङो"))) + ("ngO" (("ङौ"))) + ("ngR" (("ङृ"))) + ("nguu" (("ङू"))) + ("ngu" (("ङु"))) + ("ng^" (("ङ्"))) + ("ng" (("ङ्"))) + ("Nii" (("णी"))) + ("nii" (("नी") ("णी"))) + ("Ni" (("णि") ("ण्णि"))) + ("NI" (("णी"))) + ("ni" (("नि") ("णि") ("नै"))) + ("nI" (("नी") ("णी"))) + ("njaa" (("ञा") ("ञ्चा"))) + ("njae" (("ञै") ("ञ्ञै"))) + ("njaH" (("ञः"))) + ("njai" (("ञै") ("ञ्ञै"))) + ("njaM" (("ञँ"))) + ("njau" (("ञौ") ("ञे") ("ञ्ञौ"))) + ("nja" (("ञ") ("ञ्च") ("ञ्ञ"))) + ("njA" (("ञा"))) + ("njee" (("ञी") ("ञ्ची"))) + ("njei" (("ञ्चै") ("ञै") ("ञ्ञै"))) + ("nje" (("ञे") ("ञ्ञे") ("ञ्चे"))) + ("njE" (("ञै") ("ञ्ञै"))) + ("njii" (("ञी"))) + ("njI" (("ञि"))) + ("nji" (("ञि") ("ञ्ञि") ("ञ्चि"))) + ("njoo" (("ञू") ("ञ्ञू"))) + ("njou" (("ञे"))) + ("njo" (("ञो") ("ञ्ञौ") ("ञ्चो"))) + ("njO" (("ञौ") ("ञ्ञौ") ("ञ्चौ"))) + ("njR" (("ञृ"))) + ("njuu" (("ञू") ("ञ्ञू") ("ञ्चू"))) + ("nju" (("ञु") ("ञ्ञु") ("ञ्चु"))) + ("njU" (("ञू"))) + ("nj^" (("ञ्"))) + ("nj" (("ञ्") ("ञ्ञ्"))) + ("Noo" (("णू"))) + ("noo" (("नू") ("णू"))) + ("Nou" (("णे"))) + ("nou" (("नौ"))) + ("No" (("णो") ("नौ"))) + ("NO" (("णौ"))) + ("no" (("नो") ("णो") ("नौ"))) + ("nO" (("नौ"))) + ("NR" (("णृ"))) + ("nR" (("नृ"))) + ("Nuu" (("णू"))) + ("nuu" (("नू") ("णू"))) + ("Nu" (("णु"))) + ("NU" (("णू"))) + ("nu" (("नु") ("णु") ("ण्"))) + ("nU" (("नू") ("णू"))) + ("N^" (("ण्"))) + ("N~" (("ण्"))) + ("N_" (("ण्"))) + ("N" (("ण्") ("ण्") ("ण्ण्") ("न्") ("एन्"))) + ("n^" (("न्"))) + ("n~" (("न्"))) + ("n_" (("न्"))) + ("n" (("न्") ("न्") ("ण्") ("ण्") ("न्न्") ("एन्"))) + ("oo" (("ऊ") ("औ"))) + ("ou" (("औ"))) + ("o" (("ओ"))) + ("O" (("औ"))) + ("@o" (("ॊ"))) + ("paa" (("पा"))) + ("pae" (("पै"))) + ("paH" (("पः"))) + ("pai" (("पै") ("पय्") ("पाय्"))) + ("paM" (("पँ"))) + ("pau" (("पौ") ("पौ"))) + ("pa" (("प"))) + ("Pa" (("प"))) + ("pA" (("पा"))) + ("Pee" (("पि"))) + ("pee" (("पि") ("पै"))) + ("pei" (("पेय्") ("पै"))) + ("pe" (("पे") ("पि"))) + ("pE" (("पै"))) + ("phaa" (("फा"))) + ("phaH" (("फः"))) + ("phai" (("फै"))) + ("phaM" (("फँ"))) + ("phau" (("फौ") ("फे"))) + ("pha" (("फ"))) + ("phA" (("फा"))) + ("phee" (("फि"))) + ("phei" (("फै"))) + ("phe" (("फे"))) + ("phE" (("फै"))) + ("phii" (("फि"))) + ("phi" (("फि"))) + ("phI" (("फी"))) + ("phoo" (("फू"))) + ("phou" (("फे"))) + ("pho" (("फो") ("फौ"))) + ("phO" (("फौ"))) + ("phR" (("फृ"))) + ("phuu" (("फू"))) + ("phu" (("फु"))) + ("phU" (("फू"))) + ("ph^" (("फ्"))) + ("ph" (("फ्") ("पि.एच्."))) + ("pii" (("पि"))) + ("pI" (("पि"))) + ("Pi" (("पि") )) + ("pi" (("पि") ("पै") ("प्पि"))) + ("Poo" (("पू"))) + ("poo" (("पू") ("पौ"))) + ("pou" (("पौ"))) + ("po" (("पो"))) + ("pO" (("पौ"))) + ("pR" (("पृ"))) + ("puu" (("पू"))) + ("pu" (("पु"))) + ("Pu" (("पु"))) + ("pU" (("पू"))) + ("p^" (("प्"))) + ("p" (("प्") ("प्प्") ("पि"))) + ("q" (("क्यु"))) + ("Q" (("क्यू"))) + ("Raa" (("रा"))) + ("raa" (("रा") ("रा"))) + ("rae" (("रै"))) + ("Rae" (("रै"))) + ("raH" (("रः"))) + ("RaH" (("रः"))) + ("rai" (("रै") ("राय्"))) + ("Rai" (("रै") ("राय्"))) + ("raM" (("रँ"))) + ("RaM" (("रँ"))) + ("rau" (("रौ"))) + ("Rau" (("रौ"))) + ("ra" (("र") ("र"))) + ("Ra" (("र") ("र") ("रा"))) + ("rA" (("रा"))) + ("RA" (("रा"))) + ("ree" (("री"))) + ("Ree" (("री") ("री") ("रै"))) + ("rei" (("रै") ("रेय्"))) + ("Rei" (("रै") ("रेय्"))) + ("re" (("रे"))) + ("Re" (("रे"))) + ("rE" (("रै"))) + ("RE" (("रै"))) + ("rii" (("री"))) + ("Rii" (("री"))) + ("rI" (("रि"))) + ("RI" (("रि"))) + ("Ri" (("रि") ("रि"))) + ("ri" (("रि") ("रि") ("रै") ("रै"))) + ("roo" (("रू"))) + ("Roo" (("रू") ("रू"))) + ("rou" (("रौ"))) + ("Rou" (("रौ"))) + ("Ro" (("रो"))) + ("ro" (("रो") ("रौ"))) + ("rO" (("रौ"))) + ("RO" (("रौ"))) + ("rr" (("ऋ"))) + ("RR" (("ऋ"))) + ("rR" (("रृ"))) + ("ruu" (("रू"))) + ("Ruu" (("रू") ("रू"))) + ("ru" (("रु") ("रु"))) + ("Ru" (("रु") ("रु"))) + ("rU" (("रू"))) + ("RU" (("रू"))) + ("r^" (("ऋ"))) + ("r~" (("र्"))) + ("r_" (("र्"))) + ("R^" (("र्"))) + ("R~" (("र्"))) + ("R_" (("र्"))) + ("r" (("र्") ("र्") ("आर"))) + ("R" (("र्") ("र्") ("आर"))) + ("Saa" (("शा") ("सा"))) + ("saa" (("सा") ("शा"))) + ("Sae" (("शै"))) + ("sae" (("सै"))) + ("SaH" (("शः") ("षा"))) + ("saH" (("सः"))) + ("Sai" (("शै") ("सै") ("साय"))) + ("sai" (("सै") ("साय्"))) + ("SaM" (("शँ"))) + ("saM" (("सँ"))) + ("Sau" (("शौ") ("सौ"))) + ("sau" (("सौ") ("से"))) + ("Sa" (("श") ("स"))) + ("SA" (("शा") ("सा"))) + ("sa" (("स") ("श"))) + ("sA" (("सा"))) + ("See" (("शि") ("सि"))) + ("see" (("सी") ("शी"))) + ("Sei" (("शै") ("सि"))) + ("sei" (("सै"))) + ("Se" (("शे") ("से") ("सि"))) + ("SE" (("शै") ("एस.इ."))) + ("se" (("से") ("सि"))) + ("sE" (("सै"))) + ("shaa" (("षा"))) + ("Shaa" (("षा"))) + ("shae" (("षै"))) + ("Shae" (("षै"))) + ("shaH" (("षः"))) + ("ShaH" (("षः"))) + ("shai" (("षै"))) + ("Shai" (("षै"))) + ("shaM" (("षँ"))) + ("ShaM" (("षँ"))) + ("shau" (("षौ") ("षे"))) + ("Shau" (("षौ") ("षौ") ("षे"))) + ("sha" (("ष"))) + ("Sha" (("ष") ("ष") ("षा"))) + ("shA" (("षा"))) + ("ShA" (("षा"))) + ("Shee" (("षी"))) + ("shee" (("षी") ("षी"))) + ("shei" (("षै"))) + ("Shei" (("षै"))) + ("she" (("षे") ("षि"))) + ("She" (("षे") ("षि"))) + ("shE" (("षै"))) + ("ShE" (("षै"))) + ("shii" (("षी"))) + ("Shii" (("षी"))) + ("shi" (("षि"))) + ("Shi" (("षि"))) + ("shI" (("षी"))) + ("ShI" (("षी"))) + ("shoo" (("षू"))) + ("Shoo" (("षू") ("षू"))) + ("shou" (("षे"))) + ("Shou" (("षे"))) + ("Sho" (("षो"))) + ("sho" (("षो") ("षौ"))) + ("shO" (("षौ"))) + ("ShO" (("षौ"))) + ("shR" (("षृ"))) + ("ShR" (("षृ"))) + ("shuu" (("षू"))) + ("Shuu" (("षू"))) + ("shu" (("षु"))) + ("Shu" (("षु") ("षु"))) + ("shU" (("षू"))) + ("ShU" (("षू"))) + ("sh^" (("ष्"))) + ("sh" (("ष्"))) + ("Sh^" (("ष्"))) + ("Sh" (("ष्") ("ष्"))) + ("Sii" (("शि"))) + ("sii" (("सी"))) + ("Si" (("शि") ("सि"))) + ("SI" (("शी") ("एस्.ऐ."))) + ("si" (("सि") ("शि"))) + ("sI" (("सी"))) + ("Soo" (("शू") ("सू"))) + ("soo" (("सू") ("शू"))) + ("Sou" (("शे") ("से"))) + ("sou" (("से"))) + ("So" (("शो") ("सो") ("सौ"))) + ("SO" (("शौ"))) + ("so" (("सो") ("शो") ("सौ"))) + ("sO" (("सौ"))) + ("SR" (("शृ") ("एस.आर"))) + ("sR" (("सृ"))) + ("Suu" (("शू"))) + ("suu" (("सू") ("शू"))) + ("Su" (("शु") ("सु"))) + ("SU" (("शू"))) + ("su" (("सु") ("शु"))) + ("sU" (("सू"))) + ("S^" (("श्"))) + ("S" (("श्") ("स्") ("श्श्") ("एस्"))) + ("s^" (("स्"))) + ("s" (("स्") ("श्") ("स्स्") ("एस्"))) + ("taa" (("टा"))) + ("Taa" (("ठा"))) + ("tae" (("टै"))) + ("Tae" (("ठै"))) + ("taH" (("टः"))) + ("TaH" (("ठः"))) + ("tai" (("टै") ("टाय्"))) + ("Tai" (("ठै"))) + ("taM" (("टँ"))) + ("TaM" (("ठँ"))) + ("tau" (("टौ") ("टे"))) + ("Tau" (("ठौ") ("ठे"))) + ("ta" (("ट") ("र्र") ("ठ"))) + ("tA" (("टा"))) + ("Ta" (("ठ") ("ट") ("त"))) + ("TA" (("ठा"))) + ("tea" (("टी") ("र्रि"))) + ("tee" (("टी") ("र्री"))) + ("Tee" (("ठी"))) + ("tei" (("टै") ("टेय्"))) + ("Tei" (("ठै"))) + ("te" (("टे") ("र्रे") ("ठे"))) + ("tE" (("टै"))) + ("Te" (("ठे") ("टे") ("ते"))) + ("TE" (("ठै"))) + ("thaa" (("ता") ("त्ता"))) + ("Thaa" (("था") ("ता"))) + ("thae" (("तै"))) + ("Thae" (("थै"))) + ("thaH" (("तः"))) + ("ThaH" (("थः"))) + ("thai" (("तै"))) + ("Thai" (("थै") ("तै"))) + ("thaM" (("तँ") ("त्तँ"))) + ("ThaM" (("थँ"))) + ("thau" (("तौ") ("ते"))) + ("Thau" (("थौ") ("थे"))) + ("tha" (("त") ("ध") ("त्त") ("द्ध") ("थ"))) + ("thA" (("ता"))) + ("Tha" (("थ") ("त"))) + ("ThA" (("था"))) + ("thee" (("ती") ("तै"))) + ("Thee" (("थि") ("ति"))) + ("thei" (("तै") ("तेय्"))) + ("Thei" (("थै") ("तेय्"))) + ("the" (("ते"))) + ("thE" (("तै"))) + ("The" (("थे") ("दि") ("ते"))) + ("ThE" (("थै"))) + ("thii" (("ती") ("त्ती"))) + ("Thii" (("थि"))) + ("thi" (("ति") ("त्ति") ("त्थि") ("थि") ("धि") ("द्धि") ("तै"))) + ("thI" (("ती"))) + ("Thi" (("थि") ("ति") ("त्थि"))) + ("ThI" (("थी"))) + ("thoo" (("तू") ("तौ"))) + ("Thoo" (("थू") ("तू"))) + ("thou" (("ते"))) + ("Thou" (("थे"))) + ("tho" (("तो") ("तौ") ("त्तो"))) + ("thO" (("तौ") ("त्तौ"))) + ("Tho" (("थो"))) + ("ThO" (("थौ"))) + ("thR" (("तृ"))) + ("ThR" (("थृ") ("तृ"))) + ("thuu" (("तू"))) + ("Thuu" (("थू") ("तू"))) + ("thu" (("तु") ("त्तु"))) + ("thU" (("तू"))) + ("Thu" (("थु") ("तु"))) + ("ThU" (("थू") ("तू"))) + ("th^" (("त्"))) + ("th" (("त्") ("त्त्"))) + ("Th^" (("थ्"))) + ("Th" (("थ्"))) + ("tii" (("टी"))) + ("Tii" (("ठी"))) + ("ti" (("टि") ("ट्टि") ("र्रि") ("ठि") ("टै"))) + ("tI" (("टी") ("र्री"))) + ("Ti" (("ठि") ("टि") ("ति") ("तै"))) + ("TI" (("ठी"))) + ("too" (("टू") ("र्रू"))) + ("Too" (("ठू") ("टू"))) + ("tou" (("टे"))) + ("Tou" (("ठे"))) + ("to" (("टो") ("टु") ("र्रु"))) + ("tO" (("टौ"))) + ("To" (("ठो") ("टु") ("तो"))) + ("TO" (("ठौ"))) + ("tR" (("टृ"))) + ("TR" (("ठृ"))) + ("TTa" (("ट्ट"))) + ("TTI" (("टि.टि.ऐ."))) + ("TTR" (("टि.टि.आर्."))) + ("TT" (("टि.टि."))) + ("tuu" (("टू") ("र्रू"))) + ("Tuu" (("ठू"))) + ("tu" (("टु") ("र्रु") ("ट्टु"))) + ("tU" (("टू") ("र्रू"))) + ("Tu" (("ठु") ("टु"))) + ("TU" (("ठू"))) +("t^" (("ट्"))) + ("t" (("ट्") ("ट्ट्") ("र्र्") ("त्") ("टि"))) + ("T^" (("ठ्"))) + ("T" (("ठ्") ("टि"))) + ("uu" (("ऊ"))) + ("u" (("उ") ("ऊ") ("यु"))) + ("U" (("ऊ"))) + ("vaa" (("वा"))) + ("Vaa" (("वा"))) + ("vae" (("वै"))) + ("vaH" (("वः"))) + ("vai" (("वै") ("वय्"))) + ("vaM" (("वँ"))) + ("vau" (("वौ") ("वे"))) + ("va" (("व") ("वा"))) + ("Va" (("व") ("व्व") ("वा"))) + ("vA" (("वा"))) + ("vee" (("वि") ("वै"))) + ("vei" (("वैय्") ("वै"))) + ("ve" (("वे"))) + ("vE" (("वै"))) + ("vii" (("वि"))) + ("vi" (("वि"))) + ("vI" (("वि"))) + ("Vi" (("वि"))) + ("voo" (("वू"))) + ("vou" (("वे"))) + ("vo" (("वो") ("वौ"))) + ("vO" (("वौ"))) + ("vR" (("वृ"))) + ("vuu" (("वू"))) + ("vu" (("वु"))) + ("vU" (("वू"))) + ("V" (("वि"))) + ("v^" (("व्"))) + ("v" (("व्") ("व्व्") ("वि"))) + ("waa" (("वा"))) + ("wae" (("वै"))) + ("waH" (("वः"))) + ("wai" (("वै"))) + ("waM" (("वँ"))) + ("wau" (("वौ"))) + ("wa" (("व"))) + ("wA" (("वा"))) + ("wee" (("वि"))) + ("wei" (("वै"))) + ("we" (("वे"))) + ("wE" (("वै"))) + ("wii" (("वि"))) + ("wi" (("वि"))) + ("wI" (("वि"))) + ("woo" (("वू"))) + ("wou" (("वे"))) + ("wo" (("वो"))) + ("wO" (("वौ"))) + ("wR" (("वृ"))) + ("wuu" (("वू"))) + ("wu" (("वु"))) + ("wU" (("वू"))) + ("w^" (("व्"))) + ("w" (("व्") ("व्व्") ("डब्ल्यू"))) + ("xaa" (("क्षा"))) + ("xaH" (("क्षः"))) + ("xai" (("क्षै"))) + ("xaM" (("क्षँ"))) + ("xau" (("क्षौ") ("क्षे"))) + ("xa" (("क्ष") ("क्स") ("क्से"))) + ("xA" (("क्षा"))) + ("xee" (("क्षी"))) + ("xei" (("क्षै"))) + ("xe" (("क्षे") ("क्षै") ("क्से") ("क्सि") ("क्षि"))) + ("xE" (("क्षै"))) + ("xii" (("क्षी"))) + ("xi" (("क्षि") ("क्सि"))) + ("xI" (("क्षी"))) + ("xoo" (("क्षू"))) + ("xou" (("क्षे"))) + ("xo" (("क्षो"))) + ("xO" (("क्षौ"))) + ("xR" (("क्षृ"))) + ("xuu" (("क्षू"))) + ("xu" (("क्षु") ("क्सु"))) + ("xU" (("क्षू"))) + ("X" (("एक्स्"))) + ("x^" (("क्ष्"))) + ("x" (("क्ष्") ("क्स्") ("एक्स्"))) + ("yaa" (("या"))) + ("Yaa" (("या"))) + ("yae" (("यै"))) + ("yaH" (("यः") ("यः"))) + ("yai" (("यै"))) + ("Yai" (("यै"))) + ("yaM" (("यँ") ("यँ"))) + ("yau" (("यौ") ("ये"))) + ("Yau" (("यौ") ("ये"))) + ("ya" (("य"))) + ("Ya" (("य"))) + ("yA" (("या"))) + ("YA" (("या"))) + ("yei" (("यै"))) + ("Yei" (("यै"))) + ("ye" (("ये") ("यै"))) + ("Ye" (("ये") ("यै"))) + ("yE" (("यै"))) + ("YE" (("यै") ("यै"))) + ("yii" (("यी"))) + ("Yii" (("यी"))) + ("yi" (("यि"))) + ("yI" (("यि"))) + ("Yi" (("यि"))) + ("YI" (("यी"))) + ("yoo" (("यू"))) + ("Yoo" (("यू"))) + ("you" (("ये") ("यू") ("यू") ("ये"))) + ("yo" (("यो"))) + ("Yo" (("यो") ("यौ"))) + ("yO" (("यौ"))) + ("YO" (("यौ"))) + ("yR" (("यृ"))) + ("YR" (("यृ"))) + ("yuu" (("यू"))) + ("Yuu" (("यू"))) + ("yu" (("यु"))) + ("Yu" (("यु"))) + ("yU" (("यू"))) + ("YU" (("यू"))) + ("y^" (("य्"))) + ("y" (("य्") ("य्य्") ("वै"))) + ("Y" (("वै"))) + ("zaa" (("शा") ("सा"))) + ("zaH" (("शः"))) + ("zai" (("शै"))) + ("zaM" (("शँ"))) + ("zau" (("शौ"))) + ("za" (("श") ("स"))) + ("zA" (("शा"))) + ("zee" (("शी") ("सी"))) + ("zei" (("शै"))) + ("ze" (("शे"))) + ("zE" (("शै"))) + ("zhaa" (("षा"))) + ("zhae" (("षै"))) + ("zhaH" (("षः"))) + ("zhai" (("षै"))) + ("zhaM" (("षँ"))) + ("zhau" (("षौ") ("षे"))) + ("zha" (("ष"))) + ("zhA" (("षा"))) + ("zhee" (("षी"))) + ("zhei" (("षै"))) + ("zhe" (("षे"))) + ("zhE" (("षै"))) + ("zhii" (("षी"))) + ("zhi" (("षि"))) + ("zhI" (("षी"))) + ("zhoo" (("षू"))) + ("zhou" (("षे"))) + ("zho" (("षो"))) + ("zhO" (("षौ"))) + ("zhR" (("षृ"))) + ("zhuu" (("षू"))) + ("zhu" (("षु"))) + ("zhU" (("षू"))) + ("zh^" (("ष्"))) + ("zh" (("ष्"))) + ("zii" (("शी"))) + ("zi" (("शि") ("सि"))) + ("zI" (("शी"))) + ("zoo" (("शू") ("सू"))) + ("zou" (("शे"))) + ("zo" (("शो"))) + ("zO" (("शौ"))) + ("zR" (("शृ"))) + ("zuu" (("शू"))) + ("zu" (("शु") ("सु"))) + ("zU" (("शू"))) + ("z^" (("श्"))) + ("z" (("श्") ("स्") ("इसड्"))) +) +) + + + +(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: diff --git a/input-methods/m17n/swanalekha/mr-swanalekha.png b/input-methods/m17n/swanalekha/mr-swanalekha.png Binary files differnew file mode 100755 index 0000000..3e7c31d --- /dev/null +++ b/input-methods/m17n/swanalekha/mr-swanalekha.png 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: + diff --git a/input-methods/m17n/swanalekha/or-swanalekha.png b/input-methods/m17n/swanalekha/or-swanalekha.png Binary files differnew file mode 100755 index 0000000..489ddc8 --- /dev/null +++ b/input-methods/m17n/swanalekha/or-swanalekha.png 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: diff --git a/input-methods/m17n/swanalekha/pa-swanalekha.png b/input-methods/m17n/swanalekha/pa-swanalekha.png Binary files differnew file mode 100755 index 0000000..fc8fcb3 --- /dev/null +++ b/input-methods/m17n/swanalekha/pa-swanalekha.png diff --git a/input-methods/m17n/swanalekha/ta-swanalekha.mim b/input-methods/m17n/swanalekha/ta-swanalekha.mim new file mode 100755 index 0000000..5427017 --- /dev/null +++ b/input-methods/m17n/swanalekha/ta-swanalekha.mim @@ -0,0 +1,1287 @@ +(input-method ta swanalekha) + +(description "Swanalekha Tamil input method") + + +(title "tamil") +(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" (("ா") ("ி.ஏ."))) + ("baa" (("ா"))) + ("Baa" (("ா") ("ா"))) + ("bae" (("ை"))) + ("baH" (("ஃ"))) + ("BaH" (("ஃ"))) + ("bai" (("ை") ("ாய்"))) + ("Bai" (("ை"))) + ("bau" (("ௌ") ("ௌ") ("ௌ"))) + ("Bau" (("ௌ") ("ே"))) + ("be" (("ே"))) + ("bE" (("ை"))) + ("Be" (("ே"))) + ("BE" (("ை"))) + ("bee" (("ீ"))) + ("Bee" (("ீ"))) + ("bei" (("ை"))) + ("Bei" (("ை"))) + ("bh^" (("்"))) + ("bh" (("்"))) + ("bhA" (("ா"))) + ("bhaa" (("ா"))) + ("bhae" (("ை"))) + ("bhaH" (("ஃ"))) + ("bhai" (("ை") ("ாய்"))) + ("bhau" (("ௌ") ("ே"))) + ("bhe" (("ே"))) + ("bhE" (("ை"))) + ("bhee" (("ீ"))) + ("bhei" (("ை"))) + ("bhi" (("ி"))) + ("bhI" (("ி"))) + ("bhii" (("ீ"))) + ("bho" (("ோ"))) + ("bhO" (("ௌ"))) + ("bhoo" (("ூ"))) + ("bhou" (("ே"))) + ("bhu" (("ு"))) + ("bhU" (("ூ"))) + ("bhuu" (("ூ"))) + ("bi" (("ி") ("ை"))) + ("bI" (("ீ"))) + ("Bi" (("ி") ("ை"))) + ("BI" (("ீ"))) + ("bii" (("ீ"))) + ("Bii" (("ீ"))) + ("bo" (("ோ"))) + ("bO" (("ௌ"))) + ("Bo" (("ோ") ("ௌ"))) + ("BO" (("ௌ"))) + ("boo" (("ூ") ("ௌ"))) + ("Boo" (("ூ"))) + ("bou" (("ௌ"))) + ("Bou" (("ே"))) + ("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" (("ச"))) + ("chau" (("சௌ"))) + ("Chau" (("ௌ") ("ே"))) + ("che" (("சே") ("ச்சே"))) + ("chE" (("சை"))) + ("Che" (("ே"))) + ("ChE" (("ை"))) + ("chee" (("சீ") ("ச்சீ"))) + ("Chee" (("ீ"))) + ("chei" (("சை"))) + ("Chei" (("ை"))) + ("chh^" (("்"))) + ("chh" (("்"))) + ("chha" ( ("ச்ச"))) + ("chhA" (("ா"))) + ("chhaa" (("ா"))) + ("chhae" (("ை"))) + ("chhaH" (("ஃ"))) + ("chhai" (("ை"))) + ("chhau" (("ௌ") ("ே"))) + ("chhe" (("ே"))) + ("chhE" (("ை"))) + ("chhee" (("ீ"))) + ("chhei" (("ை"))) + ("chhi" (("ீ"))) + ("chhI" (("ி"))) + ("chhii" (("ீ"))) + ("chho" (("ோ"))) + ("chhO" (("ௌ"))) + ("chhoo" (("ூ"))) + ("chhou" (("ே"))) + ("chhu" (("ு"))) + ("chhU" (("ூ"))) + ("chhuu" (("ூ"))) + ("chi" (("சி") ("ச்சி") ("சை"))) + ("chI" (("சீ"))) + ("Chi" (("ி") ("சி"))) + ("ChI" (("ீ"))) + ("chii" (("சீ"))) + ("Chii" (("ீ"))) + ("cho" (("சோ") ("சௌ"))) + ("chO" (("சௌ"))) + ("Cho" (("ோ"))) + ("ChO" (("ௌ"))) + ("choo" (("சூ") ("ச்சூ") ("சௌ"))) + ("Choo" (("ூ"))) + ("chou" (("சே"))) + ("Chou" (("ே"))) + ("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" (("ா"))) + ("daa" (("ா") ("டா"))) + ("Daa" (("ா"))) + ("dae" (("ை"))) + ("Dae" (("ை"))) + ("daH" (("ஃ"))) + ("DaH" (("ஃ"))) + ("dai" (("ை") ("ாய்"))) + ("Dai" (("ை"))) + ("dau" (("ௌ") ("ே"))) + ("Dau" (("ௌ") ("ே"))) + ("de" (("ே") ("டே") ("தே"))) + ("dE" (("ை") ("தை"))) + ("De" (("ே") ("டே"))) + ("DE" (("ை"))) + ("dee" (("ீ") ("டீ"))) + ("Dee" (("ீ"))) + ("dei" (("ை") ("ைய்"))) + ("Dei" (("ை"))) + ("dh^" (("்"))) + ("dh" (("்"))) + ("Dh^" (("்"))) + ("Dh" (("்"))) + ("dhA" (("ா"))) + ("DhA" (("ா"))) + ("dhaa" (("ா"))) + ("Dhaa" (("ா"))) + ("dhae" (("ை"))) + ("Dhae" (("ை"))) + ("dhaH" (("ஃ"))) + ("DhaH" (("ஃ"))) + ("dhai" (("ை"))) + ("Dhai" (("ை"))) + ("dhau" (("ௌ") ("ே"))) + ("Dhau" (("ௌ") ("ே"))) + ("dhe" (("ே"))) + ("dhE" (("ை"))) + ("Dhe" (("ே"))) + ("DhE" (("ை"))) + ("dhee" (("ி"))) + ("Dhee" (("ீ"))) + ("dhei" (("ை"))) + ("Dhei" (("ை"))) + ("dhi" (("ி"))) + ("dhI" (("ி"))) + ("Dhi" (("ி"))) + ("DhI" (("ீ"))) + ("dhii" (("ி"))) + ("Dhii" (("ீ"))) + ("dho" (("ோ"))) + ("dhO" (("ௌ"))) + ("Dho" (("ோ"))) + ("DhO" (("ௌ"))) + ("dhoo" (("ூ"))) + ("Dhoo" (("ூ"))) + ("dhou" (("ே"))) + ("Dhou" (("ே"))) + ("dhu" (("ு"))) + ("dhU" (("ூ"))) + ("Dhu" (("ு"))) + ("DhU" (("ூ"))) + ("dhuu" (("ூ"))) + ("Dhuu" (("ூ"))) + ("di" (("ி") ("டி") ("ி") ("ி") ("ை"))) + ("dI" (("ி") ("டி"))) + ("Di" (("ி"))) + ("DI" (("ீ"))) + ("dii" (("ீ") ("டீ"))) + ("Dii" (("ீ"))) + ("do" (("ோ"))) + ("dO" (("ௌ"))) + ("Do" (("ோ"))) + ("DO" (("ௌ"))) + ("doo" (("ூ"))) + ("Doo" (("ூ"))) + ("dou" (("ே"))) + ("Dou" (("ே"))) + ("du" (("ு") ("டு") ("ுஃ"))) + ("dU" (("ூ"))) + ("Du" (("ு") ("ு"))) + ("DU" (("ூ"))) + ("duu" (("ூ"))) + ("Duu" (("ூ"))) + ("E" (("எ") ("இ"))) + ("ee" (("ஈ"))) + ("ei" (("ஐ"))) + ("f^" (("்"))) + ("f" (("்") ("ஏ்"))) + ("fA" (("ா"))) + ("faa" (("ா"))) + ("faH" (("ஃ"))) + ("fai" (("ை"))) + ("fe" (("ே"))) + ("fE" (("ை"))) + ("fee" (("ீ"))) + ("fei" (("ை"))) + ("fi" (("ி"))) + ("fI" (("ீ"))) + ("fii" (("ீ"))) + ("fo" (("ோ"))) + ("fO" (("ௌ"))) + ("foo" (("ூ"))) + ("fou" (("ே"))) + ("fu" (("ு"))) + ("fU" (("ூ"))) + ("fuu" (("ூ"))) + ("g^" (("்"))) + ("g" (("்") ("ஜி"))) + ("G^" (("்"))) + ("G" (("்") ("ஜி") ("்ி"))) + ("ga" ( ("ஜ") ("க") )) + ("gA" (("ா"))) + ("Ga" ( ("்") ("ஜ"))) + ("GA" (("ா") ("்ா"))) + ("gaa" (("ா"))) + ("Gaa" (("ா") ("்ா"))) + ("gae" (("ை"))) + ("Gae" (("ை") ("்ை"))) + ("gaH" (("ஃ"))) + ("GaH" (("ஃ"))) + ("gai" (("ை"))) + ("Gai" (("ை") ("ய்") ("ேய்") ("்ை"))) + ("gau" (("ௌ") ("ே"))) + ("Gau" (("ௌ") ("ௌ") ("ே"))) + ("ge" (("ே"))) + ("gE" (("ை"))) + ("Ge" (("ே") ("ே") ("்ே") ("ஜே"))) + ("GE" (("ை") ("்ை"))) + ("gee" (("ீ"))) + ("Gee" (("ி") ("்ி"))) + ("gei" (("ை"))) + ("Gei" (("ை") ("்ை"))) + ("gh^" (("்"))) + ("gh" (("்"))) + ("ghA" (("ா"))) + ("ghaa" (("ா"))) + ("ghae" (("ை"))) + ("ghaH" (("ஃ"))) + ("ghai" (("ை"))) + ("ghau" (("ௌ"))) + ("ghe" (("ே"))) + ("ghE" (("ை"))) + ("ghee" (("ி"))) + ("ghei" (("ை"))) + ("ghi" (("ி"))) + ("ghI" (("ி"))) + ("ghii" (("ி"))) + ("gho" (("ோ"))) + ("ghO" (("ௌ"))) + ("ghoo" (("ூ"))) + ("ghou" (("ே"))) + ("ghu" (("ு"))) + ("ghU" (("ூ"))) + ("ghuu" (("ூ"))) + ("gi" (("ி") ("கி") ("ஜி"))) + ("gI" (("ீ"))) + ("Gi" (("ி") ("்ீ"))) + ("GI" (("ி") ("்ி") ("்ி"))) + ("gii" (("ீ"))) + ("Gii" (("ீ") ("்ீ"))) + ("go" (("ோ") ("ௌ"))) + ("gO" (("ௌ"))) + ("Go" (("ோ") ("ௌ") ("ோ") ("்ோ"))) + ("GO" (("ௌ"))) + ("goo" (("ூ") ("ௌ"))) + ("Goo" (("ூ") ("்ூ") ("ௌ") ("்ௌ"))) + ("gou" (("ே"))) + ("Gou" (("ே"))) + ("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" (("ஜ"))) + ("jau" (("ஜௌ") ("ஜே"))) + ("Jau" (("ௌ") ("ே"))) + ("je" (("ஜே") ("ஜி"))) + ("jE" (("ஜை"))) + ("Je" (("ே"))) + ("JE" (("ை"))) + ("jee" (("ஜீ"))) + ("Jee" (("ீ") ("ஜீ"))) + ("jei" (("ஜை"))) + ("Jei" (("ை"))) + ("jh^" (("்"))) + ("jh" (("்"))) + ("jhA" (("ா"))) + ("jhaa" (("ா"))) + ("jhae" (("ை"))) + ("jhaH" (("ஃ"))) + ("jhai" (("ை"))) + ("jhau" (("ௌ") ("ே"))) + ("jhe" (("ே"))) + ("jhE" (("ை"))) + ("jhee" (("ி"))) + ("jhei" (("ை"))) + ("jhi" (("ி"))) + ("jhI" (("ி"))) + ("jhii" (("ி"))) + ("jho" (("ோ"))) + ("jhO" (("ௌ"))) + ("jhoo" (("ூ") ("ௌ"))) + ("jhou" (("ே"))) + ("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" (("க"))) + ("kau" (("கௌ") ("கே"))) + ("Kau" (("ௌ"))) + ("ke" (("கே"))) + ("kE" (("கை"))) + ("Ke" (("ே") ("கே"))) + ("KE" (("ை"))) + ("kee" (("கீ"))) + ("Kee" (("ி") ("கி"))) + ("kei" (("கை") ("கேய்"))) + ("Kei" (("ை"))) + ("kh^" (("்"))) + ("kh" (("்") ("்"))) + ("kha" ( ("க்க") )) + ("khA" (("ா"))) + ("khaa" (("ா"))) + ("khae" (("ை"))) + ("khaH" (("ஃ"))) + ("khai" (("ை"))) + ("khau" (("ௌ") ("ே"))) + ("khe" (("ே"))) + ("khE" (("ை"))) + ("khee" (("ி"))) + ("khei" (("ை"))) + ("khi" (("ி") ("க்கி"))) + ("khI" (("ி"))) + ("khii" (("ி"))) + ("kho" (("ோ"))) + ("khO" (("ௌ"))) + ("khoo" (("ூ"))) + ("khou" (("ே"))) + ("khu" (("ு") ("ு"))) + ("khU" (("ூ"))) + ("khuu" (("ூ"))) + ("ki" (("கி") ("ி") ("ி") ("ி") ("கை"))) + ("Ki" (("ி") ("கி"))) + ("Kii" (("ி"))) + ("ko" (("கோ"))) + ("kO" (("கோ"))) + ("Ko" (("ோ") ("கோ") ("கௌ"))) + ("KO" (("ௌ"))) + ("koo" (("கூ") ("க"))) + ("Koo" (("ூ") ("கூ") ("கௌ"))) + ("kou" (("கே"))) + ("Kou" (("ே"))) + ("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^" (("ம்"))) + ("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" (("ஓ"))) + ("O" (("ஔ"))) + ("oo" (("ஊ") ("ஔ"))) + ("ou" (("ஔ"))) + ("p^" (("ப்"))) + ("p" (("ப்") ("ப்ப்") ("பி"))) + ("pa" (("ப"))) + ("pA" (("பா"))) + ("Pa" (("ப"))) + ("paa" (("பா"))) + ("pae" (("பை"))) + ("paH" (("பஃ"))) + ("pai" (("பை") ("பய்") ("பாய்"))) + ("paM" (("ப"))) + ("pau" (("பௌ") ("பௌ"))) + ("pe" (("பே") ("பி"))) + ("pE" (("பை"))) + ("pee" (("பி") ("பை"))) + ("Pee" (("பி"))) + ("pei" (("பேய்") ("பை"))) + ("ph^" (("்"))) + ("ph" (("்") ("பி.ஏச்."))) + ("phA" (("ா"))) + ("phaa" (("ா"))) + ("phaH" (("ஃ"))) + ("phai" (("ை"))) + ("phau" (("ௌ") ("ே"))) + ("phe" (("ே"))) + ("phE" (("ை"))) + ("phee" (("ி"))) + ("phei" (("ை"))) + ("phi" (("ி"))) + ("phI" (("ீ"))) + ("phii" (("ி"))) + ("pho" (("ோ") ("ௌ"))) + ("phO" (("ௌ"))) + ("phoo" (("ூ"))) + ("phou" (("ே"))) + ("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" (("ஷ") ("ஷ") ("ஷா"))) + ("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" (("ட"))) + ("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" (("த") ("த்த"))) + ("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" (("ட"))) + ("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" (("ஷ"))) + ("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: diff --git a/input-methods/m17n/swanalekha/ta-swanalekha.png b/input-methods/m17n/swanalekha/ta-swanalekha.png Binary files differnew file mode 100755 index 0000000..72a6be7 --- /dev/null +++ b/input-methods/m17n/swanalekha/ta-swanalekha.png 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: + diff --git a/input-methods/m17n/swanalekha/te-swanalekha.png b/input-methods/m17n/swanalekha/te-swanalekha.png Binary files differnew file mode 100755 index 0000000..05a0ffd --- /dev/null +++ b/input-methods/m17n/swanalekha/te-swanalekha.png |