ige (empty) → 0.1.0.0

raw patch · 12 files changed

+5949/−0 lines, 12 filesdep +aesondep +arraydep +basesetup-changed

Dependencies added: aeson, array, base, bytestring, cairo, conduit, conduit-combinators, containers, directory, fgl, gtk, linear, megaparsec, microlens-platform, mtl, mwc-random, protolude, stm, stm-chans, stm-conduit, text, transformers, wl-pprint-text

Files

• ChangeLog.md +5/−0
• LICENSE +674/−0
• Setup.hs +2/−0
• ige.cabal +70/−0
• src/IGE/Control.hs +260/−0
• src/IGE/Keys.hs +4544/−0
• src/IGE/Layout.hs +104/−0
• src/IGE/Render.hs +101/−0
• src/IGE/Serialization.hs +13/−0
• src/IGE/Types.hs +115/−0
• src/IGE/UI.hs +44/−0
• src/Main.hs +17/−0

@@ -0,0 +1,5 @@+# Revision history for ige++## 0.1.0.0  -- 2017-07-07++* Basic graph editing is working, including saving and reading from files.

@@ -0,0 +1,674 @@+              GNU GENERAL PUBLIC LICENSE+                Version 3, 29 June 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++                     Preamble++  The GNU General Public License is a free, copyleft license for+software and other kinds of works.++  The licenses for most software and other practical works are designed+to take away your freedom to share and change the works.  By contrast,+the GNU General Public License is intended to guarantee your freedom to+share and change all versions of a program--to make sure it remains free+software for all its users.  We, the Free Software Foundation, use the+GNU General Public License for most of our software; it applies also to+any other work released this way by its authors.  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+them 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 prevent others from denying you+these rights or asking you to surrender the rights.  Therefore, you have+certain responsibilities if you distribute copies of the software, or if+you modify it: responsibilities to respect the freedom of others.++  For example, if you distribute copies of such a program, whether+gratis or for a fee, you must pass on to the recipients the same+freedoms that you received.  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.++  Developers that use the GNU GPL protect your rights with two steps:+(1) assert copyright on the software, and (2) offer you this License+giving you legal permission to copy, distribute and/or modify it.++  For the developers' and authors' protection, the GPL clearly explains+that there is no warranty for this free software.  For both users' and+authors' sake, the GPL requires that modified versions be marked as+changed, so that their problems will not be attributed erroneously to+authors of previous versions.++  Some devices are designed to deny users access to install or run+modified versions of the software inside them, although the manufacturer+can do so.  This is fundamentally incompatible with the aim of+protecting users' freedom to change the software.  The systematic+pattern of such abuse occurs in the area of products for individuals to+use, which is precisely where it is most unacceptable.  Therefore, we+have designed this version of the GPL to prohibit the practice for those+products.  If such problems arise substantially in other domains, we+stand ready to extend this provision to those domains in future versions+of the GPL, as needed to protect the freedom of users.++  Finally, every program is threatened constantly by software patents.+States should not allow patents to restrict development and use of+software on general-purpose computers, but in those that do, we wish to+avoid the special danger that patents applied to a free program could+make it effectively proprietary.  To prevent this, the GPL assures that+patents cannot be used to render the program non-free.++  The precise terms and conditions for copying, distribution and+modification follow.++                TERMS AND CONDITIONS++  0. Definitions.++  "This License" refers to version 3 of the GNU General Public License.++  "Copyright" also means copyright-like laws that apply to other kinds of+works, such as semiconductor masks.++  "The Program" refers to any copyrightable work licensed under this+License.  Each licensee is addressed as "you".  "Licensees" and+"recipients" may be individuals or organizations.++  To "modify" a work means to copy from or adapt all or part of the work+in a fashion requiring copyright permission, other than the making of an+exact copy.  The resulting work is called a "modified version" of the+earlier work or a work "based on" the earlier work.++  A "covered work" means either the unmodified Program or a work based+on the Program.++  To "propagate" a work means to do anything with it that, without+permission, would make you directly or secondarily liable for+infringement under applicable copyright law, except executing it on a+computer or modifying a private copy.  Propagation includes copying,+distribution (with or without modification), making available to the+public, and in some countries other activities as well.++  To "convey" a work means any kind of propagation that enables other+parties to make or receive copies.  Mere interaction with a user through+a computer network, with no transfer of a copy, is not conveying.++  An interactive user interface displays "Appropriate Legal Notices"+to the extent that it includes a convenient and prominently visible+feature that (1) displays an appropriate copyright notice, and (2)+tells the user that there is no warranty for the work (except to the+extent that warranties are provided), that licensees may convey the+work under this License, and how to view a copy of this License.  If+the interface presents a list of user commands or options, such as a+menu, a prominent item in the list meets this criterion.++  1. Source Code.++  The "source code" for a work means the preferred form of the work+for making modifications to it.  "Object code" means any non-source+form of a work.++  A "Standard Interface" means an interface that either is an official+standard defined by a recognized standards body, or, in the case of+interfaces specified for a particular programming language, one that+is widely used among developers working in that language.++  The "System Libraries" of an executable work include anything, other+than the work as a whole, that (a) is included in the normal form of+packaging a Major Component, but which is not part of that Major+Component, and (b) serves only to enable use of the work with that+Major Component, or to implement a Standard Interface for which an+implementation is available to the public in source code form.  A+"Major Component", in this context, means a major essential component+(kernel, window system, and so on) of the specific operating system+(if any) on which the executable work runs, or a compiler used to+produce the work, or an object code interpreter used to run it.++  The "Corresponding Source" for a work in object code form means all+the source code needed to generate, install, and (for an executable+work) run the object code and to modify the work, including scripts to+control those activities.  However, it does not include the work's+System Libraries, or general-purpose tools or generally available free+programs which are used unmodified in performing those activities but+which are not part of the work.  For example, Corresponding Source+includes interface definition files associated with source files for+the work, and the source code for shared libraries and dynamically+linked subprograms that the work is specifically designed to require,+such as by intimate data communication or control flow between those+subprograms and other parts of the work.++  The Corresponding Source need not include anything that users+can regenerate automatically from other parts of the Corresponding+Source.++  The Corresponding Source for a work in source code form is that+same work.++  2. Basic Permissions.++  All rights granted under this License are granted for the term of+copyright on the Program, and are irrevocable provided the stated+conditions are met.  This License explicitly affirms your unlimited+permission to run the unmodified Program.  The output from running a+covered work is covered by this License only if the output, given its+content, constitutes a covered work.  This License acknowledges your+rights of fair use or other equivalent, as provided by copyright law.++  You may make, run and propagate covered works that you do not+convey, without conditions so long as your license otherwise remains+in force.  You may convey covered works to others for the sole purpose+of having them make modifications exclusively for you, or provide you+with facilities for running those works, provided that you comply with+the terms of this License in conveying all material for which you do+not control copyright.  Those thus making or running the covered works+for you must do so exclusively on your behalf, under your direction+and control, on terms that prohibit them from making any copies of+your copyrighted material outside their relationship with you.++  Conveying under any other circumstances is permitted solely under+the conditions stated below.  Sublicensing is not allowed; section 10+makes it unnecessary.++  3. Protecting Users' Legal Rights From Anti-Circumvention Law.++  No covered work shall be deemed part of an effective technological+measure under any applicable law fulfilling obligations under article+11 of the WIPO copyright treaty adopted on 20 December 1996, or+similar laws prohibiting or restricting circumvention of such+measures.++  When you convey a covered work, you waive any legal power to forbid+circumvention of technological measures to the extent such circumvention+is effected by exercising rights under this License with respect to+the covered work, and you disclaim any intention to limit operation or+modification of the work as a means of enforcing, against the work's+users, your or third parties' legal rights to forbid circumvention of+technological measures.++  4. Conveying Verbatim Copies.++  You may convey 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;+keep intact all notices stating that this License and any+non-permissive terms added in accord with section 7 apply to the code;+keep intact all notices of the absence of any warranty; and give all+recipients a copy of this License along with the Program.++  You may charge any price or no price for each copy that you convey,+and you may offer support or warranty protection for a fee.++  5. Conveying Modified Source Versions.++  You may convey a work based on the Program, or the modifications to+produce it from the Program, in the form of source code under the+terms of section 4, provided that you also meet all of these conditions:++    a) The work must carry prominent notices stating that you modified+    it, and giving a relevant date.++    b) The work must carry prominent notices stating that it is+    released under this License and any conditions added under section+    7.  This requirement modifies the requirement in section 4 to+    "keep intact all notices".++    c) You must license the entire work, as a whole, under this+    License to anyone who comes into possession of a copy.  This+    License will therefore apply, along with any applicable section 7+    additional terms, to the whole of the work, and all its parts,+    regardless of how they are packaged.  This License gives no+    permission to license the work in any other way, but it does not+    invalidate such permission if you have separately received it.++    d) If the work has interactive user interfaces, each must display+    Appropriate Legal Notices; however, if the Program has interactive+    interfaces that do not display Appropriate Legal Notices, your+    work need not make them do so.++  A compilation of a covered work with other separate and independent+works, which are not by their nature extensions of the covered work,+and which are not combined with it such as to form a larger program,+in or on a volume of a storage or distribution medium, is called an+"aggregate" if the compilation and its resulting copyright are not+used to limit the access or legal rights of the compilation's users+beyond what the individual works permit.  Inclusion of a covered work+in an aggregate does not cause this License to apply to the other+parts of the aggregate.++  6. Conveying Non-Source Forms.++  You may convey a covered work in object code form under the terms+of sections 4 and 5, provided that you also convey the+machine-readable Corresponding Source under the terms of this License,+in one of these ways:++    a) Convey the object code in, or embodied in, a physical product+    (including a physical distribution medium), accompanied by the+    Corresponding Source fixed on a durable physical medium+    customarily used for software interchange.++    b) Convey the object code in, or embodied in, a physical product+    (including a physical distribution medium), accompanied by a+    written offer, valid for at least three years and valid for as+    long as you offer spare parts or customer support for that product+    model, to give anyone who possesses the object code either (1) a+    copy of the Corresponding Source for all the software in the+    product that is covered by this License, on a durable physical+    medium customarily used for software interchange, for a price no+    more than your reasonable cost of physically performing this+    conveying of source, or (2) access to copy the+    Corresponding Source from a network server at no charge.++    c) Convey individual copies of the object code with a copy of the+    written offer to provide the Corresponding Source.  This+    alternative is allowed only occasionally and noncommercially, and+    only if you received the object code with such an offer, in accord+    with subsection 6b.++    d) Convey the object code by offering access from a designated+    place (gratis or for a charge), and offer equivalent access to the+    Corresponding Source in the same way through the same place at no+    further charge.  You need not require recipients to copy the+    Corresponding Source along with the object code.  If the place to+    copy the object code is a network server, the Corresponding Source+    may be on a different server (operated by you or a third party)+    that supports equivalent copying facilities, provided you maintain+    clear directions next to the object code saying where to find the+    Corresponding Source.  Regardless of what server hosts the+    Corresponding Source, you remain obligated to ensure that it is+    available for as long as needed to satisfy these requirements.++    e) Convey the object code using peer-to-peer transmission, provided+    you inform other peers where the object code and Corresponding+    Source of the work are being offered to the general public at no+    charge under subsection 6d.++  A separable portion of the object code, whose source code is excluded+from the Corresponding Source as a System Library, need not be+included in conveying the object code work.++  A "User Product" is either (1) a "consumer product", which means any+tangible personal property which is normally used for personal, family,+or household purposes, or (2) anything designed or sold for incorporation+into a dwelling.  In determining whether a product is a consumer product,+doubtful cases shall be resolved in favor of coverage.  For a particular+product received by a particular user, "normally used" refers to a+typical or common use of that class of product, regardless of the status+of the particular user or of the way in which the particular user+actually uses, or expects or is expected to use, the product.  A product+is a consumer product regardless of whether the product has substantial+commercial, industrial or non-consumer uses, unless such uses represent+the only significant mode of use of the product.++  "Installation Information" for a User Product means any methods,+procedures, authorization keys, or other information required to install+and execute modified versions of a covered work in that User Product from+a modified version of its Corresponding Source.  The information must+suffice to ensure that the continued functioning of the modified object+code is in no case prevented or interfered with solely because+modification has been made.++  If you convey an object code work under this section in, or with, or+specifically for use in, a User Product, and the conveying occurs as+part of a transaction in which the right of possession and use of the+User Product is transferred to the recipient in perpetuity or for a+fixed term (regardless of how the transaction is characterized), the+Corresponding Source conveyed under this section must be accompanied+by the Installation Information.  But this requirement does not apply+if neither you nor any third party retains the ability to install+modified object code on the User Product (for example, the work has+been installed in ROM).++  The requirement to provide Installation Information does not include a+requirement to continue to provide support service, warranty, or updates+for a work that has been modified or installed by the recipient, or for+the User Product in which it has been modified or installed.  Access to a+network may be denied when the modification itself materially and+adversely affects the operation of the network or violates the rules and+protocols for communication across the network.++  Corresponding Source conveyed, and Installation Information provided,+in accord with this section must be in a format that is publicly+documented (and with an implementation available to the public in+source code form), and must require no special password or key for+unpacking, reading or copying.++  7. Additional Terms.++  "Additional permissions" are terms that supplement the terms of this+License by making exceptions from one or more of its conditions.+Additional permissions that are applicable to the entire Program shall+be treated as though they were included in this License, to the extent+that they are valid under applicable law.  If additional permissions+apply only to part of the Program, that part may be used separately+under those permissions, but the entire Program remains governed by+this License without regard to the additional permissions.++  When you convey a copy of a covered work, you may at your option+remove any additional permissions from that copy, or from any part of+it.  (Additional permissions may be written to require their own+removal in certain cases when you modify the work.)  You may place+additional permissions on material, added by you to a covered work,+for which you have or can give appropriate copyright permission.++  Notwithstanding any other provision of this License, for material you+add to a covered work, you may (if authorized by the copyright holders of+that material) supplement the terms of this License with terms:++    a) Disclaiming warranty or limiting liability differently from the+    terms of sections 15 and 16 of this License; or++    b) Requiring preservation of specified reasonable legal notices or+    author attributions in that material or in the Appropriate Legal+    Notices displayed by works containing it; or++    c) Prohibiting misrepresentation of the origin of that material, or+    requiring that modified versions of such material be marked in+    reasonable ways as different from the original version; or++    d) Limiting the use for publicity purposes of names of licensors or+    authors of the material; or++    e) Declining to grant rights under trademark law for use of some+    trade names, trademarks, or service marks; or++    f) Requiring indemnification of licensors and authors of that+    material by anyone who conveys the material (or modified versions of+    it) with contractual assumptions of liability to the recipient, for+    any liability that these contractual assumptions directly impose on+    those licensors and authors.++  All other non-permissive additional terms are considered "further+restrictions" within the meaning of section 10.  If the Program as you+received it, or any part of it, contains a notice stating that it is+governed by this License along with a term that is a further+restriction, you may remove that term.  If a license document contains+a further restriction but permits relicensing or conveying under this+License, you may add to a covered work material governed by the terms+of that license document, provided that the further restriction does+not survive such relicensing or conveying.++  If you add terms to a covered work in accord with this section, you+must place, in the relevant source files, a statement of the+additional terms that apply to those files, or a notice indicating+where to find the applicable terms.++  Additional terms, permissive or non-permissive, may be stated in the+form of a separately written license, or stated as exceptions;+the above requirements apply either way.++  8. Termination.++  You may not propagate or modify a covered work except as expressly+provided under this License.  Any attempt otherwise to propagate or+modify it is void, and will automatically terminate your rights under+this License (including any patent licenses granted under the third+paragraph of section 11).++  However, if you cease all violation of this License, then your+license from a particular copyright holder is reinstated (a)+provisionally, unless and until the copyright holder explicitly and+finally terminates your license, and (b) permanently, if the copyright+holder fails to notify you of the violation by some reasonable means+prior to 60 days after the cessation.++  Moreover, your license from a particular copyright holder is+reinstated permanently if the copyright holder notifies you of the+violation by some reasonable means, this is the first time you have+received notice of violation of this License (for any work) from that+copyright holder, and you cure the violation prior to 30 days after+your receipt of the notice.++  Termination of your rights under this section does not terminate the+licenses of parties who have received copies or rights from you under+this License.  If your rights have been terminated and not permanently+reinstated, you do not qualify to receive new licenses for the same+material under section 10.++  9. Acceptance Not Required for Having Copies.++  You are not required to accept this License in order to receive or+run a copy of the Program.  Ancillary propagation of a covered work+occurring solely as a consequence of using peer-to-peer transmission+to receive a copy likewise does not require acceptance.  However,+nothing other than this License grants you permission to propagate or+modify any covered work.  These actions infringe copyright if you do+not accept this License.  Therefore, by modifying or propagating a+covered work, you indicate your acceptance of this License to do so.++  10. Automatic Licensing of Downstream Recipients.++  Each time you convey a covered work, the recipient automatically+receives a license from the original licensors, to run, modify and+propagate that work, subject to this License.  You are not responsible+for enforcing compliance by third parties with this License.++  An "entity transaction" is a transaction transferring control of an+organization, or substantially all assets of one, or subdividing an+organization, or merging organizations.  If propagation of a covered+work results from an entity transaction, each party to that+transaction who receives a copy of the work also receives whatever+licenses to the work the party's predecessor in interest had or could+give under the previous paragraph, plus a right to possession of the+Corresponding Source of the work from the predecessor in interest, if+the predecessor has it or can get it with reasonable efforts.++  You may not impose any further restrictions on the exercise of the+rights granted or affirmed under this License.  For example, you may+not impose a license fee, royalty, or other charge for exercise of+rights granted under this License, and you may not initiate litigation+(including a cross-claim or counterclaim in a lawsuit) alleging that+any patent claim is infringed by making, using, selling, offering for+sale, or importing the Program or any portion of it.++  11. Patents.++  A "contributor" is a copyright holder who authorizes use under this+License of the Program or a work on which the Program is based.  The+work thus licensed is called the contributor's "contributor version".++  A contributor's "essential patent claims" are all patent claims+owned or controlled by the contributor, whether already acquired or+hereafter acquired, that would be infringed by some manner, permitted+by this License, of making, using, or selling its contributor version,+but do not include claims that would be infringed only as a+consequence of further modification of the contributor version.  For+purposes of this definition, "control" includes the right to grant+patent sublicenses in a manner consistent with the requirements of+this License.++  Each contributor grants you a non-exclusive, worldwide, royalty-free+patent license under the contributor's essential patent claims, to+make, use, sell, offer for sale, import and otherwise run, modify and+propagate the contents of its contributor version.++  In the following three paragraphs, a "patent license" is any express+agreement or commitment, however denominated, not to enforce a patent+(such as an express permission to practice a patent or covenant not to+sue for patent infringement).  To "grant" such a patent license to a+party means to make such an agreement or commitment not to enforce a+patent against the party.++  If you convey a covered work, knowingly relying on a patent license,+and the Corresponding Source of the work is not available for anyone+to copy, free of charge and under the terms of this License, through a+publicly available network server or other readily accessible means,+then you must either (1) cause the Corresponding Source to be so+available, or (2) arrange to deprive yourself of the benefit of the+patent license for this particular work, or (3) arrange, in a manner+consistent with the requirements of this License, to extend the patent+license to downstream recipients.  "Knowingly relying" means you have+actual knowledge that, but for the patent license, your conveying the+covered work in a country, or your recipient's use of the covered work+in a country, would infringe one or more identifiable patents in that+country that you have reason to believe are valid.++  If, pursuant to or in connection with a single transaction or+arrangement, you convey, or propagate by procuring conveyance of, a+covered work, and grant a patent license to some of the parties+receiving the covered work authorizing them to use, propagate, modify+or convey a specific copy of the covered work, then the patent license+you grant is automatically extended to all recipients of the covered+work and works based on it.++  A patent license is "discriminatory" if it does not include within+the scope of its coverage, prohibits the exercise of, or is+conditioned on the non-exercise of one or more of the rights that are+specifically granted under this License.  You may not convey a covered+work if you are a party to an arrangement with a third party that is+in the business of distributing software, under which you make payment+to the third party based on the extent of your activity of conveying+the work, and under which the third party grants, to any of the+parties who would receive the covered work from you, a discriminatory+patent license (a) in connection with copies of the covered work+conveyed by you (or copies made from those copies), or (b) primarily+for and in connection with specific products or compilations that+contain the covered work, unless you entered into that arrangement,+or that patent license was granted, prior to 28 March 2007.++  Nothing in this License shall be construed as excluding or limiting+any implied license or other defenses to infringement that may+otherwise be available to you under applicable patent law.++  12. No Surrender of Others' Freedom.++  If 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 convey a+covered work so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you may+not convey it at all.  For example, if you agree to terms that obligate you+to collect a royalty for further conveying from those to whom you convey+the Program, the only way you could satisfy both those terms and this+License would be to refrain entirely from conveying the Program.++  13. Use with the GNU Affero General Public License.++  Notwithstanding any other provision of this License, you have+permission to link or combine any covered work with a work licensed+under version 3 of the GNU Affero General Public License into a single+combined work, and to convey the resulting work.  The terms of this+License will continue to apply to the part which is the covered work,+but the special requirements of the GNU Affero General Public License,+section 13, concerning interaction through a network will apply to the+combination as such.++  14. Revised Versions of this License.++  The Free Software Foundation may publish revised and/or new versions of+the GNU 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 that a certain numbered version of the GNU General+Public License "or any later version" applies to it, you have the+option of following the terms and conditions either of that numbered+version or of any later version published by the Free Software+Foundation.  If the Program does not specify a version number of the+GNU General Public License, you may choose any version ever published+by the Free Software Foundation.++  If the Program specifies that a proxy can decide which future+versions of the GNU General Public License can be used, that proxy's+public statement of acceptance of a version permanently authorizes you+to choose that version for the Program.++  Later license versions may give you additional or different+permissions.  However, no additional obligations are imposed on any+author or copyright holder as a result of your choosing to follow a+later version.++  15. Disclaimer of Warranty.++  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.++  16. Limitation of Liability.++  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS+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.++  17. Interpretation of Sections 15 and 16.++  If the disclaimer of warranty and limitation of liability provided+above cannot be given local legal effect according to their terms,+reviewing courts shall apply local law that most closely approximates+an absolute waiver of all civil liability in connection with the+Program, unless a warranty or assumption of liability accompanies a+copy of the Program in return for a fee.++              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+state 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 3 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, see <http://www.gnu.org/licenses/>.++Also add information on how to contact you by electronic and paper mail.++  If the program does terminal interaction, make it output a short+notice like this when it starts in an interactive mode:++    <program>  Copyright (C) <year>  <name of author>+    This program 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, your program's commands+might be different; for a GUI interface, you would use an "about box".++  You should also get your employer (if you work as a programmer) or school,+if any, to sign a "copyright disclaimer" for the program, if necessary.+For more information on this, and how to apply and follow the GNU GPL, see+<http://www.gnu.org/licenses/>.++  The GNU 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 Lesser General+Public License instead of this License.  But first, please read+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain

@@ -0,0 +1,70 @@+-- Initial ige.cabal generated by cabal init.  For further documentation, +-- see http://haskell.org/cabal/users-guide/++name:                ige+version:             0.1.0.0+Homepage:            https://github.com/olynch/ige+synopsis:            An keyboard-driven interactive graph editor+description:         +  `IGE` attempts to build a reusable library for implementing graph editors. The intent is to allow a new class of programming languages that have non-linear structure. See `glance` (an alternative syntax for haskell) for one example of such a structure. Other applications include circuit design, commutative diagram drawing, server configuration. Currently a very early alpha.+license:             GPL-3+license-file:        LICENSE+author:              Owen Lynch+maintainer:          owen@olynch.me+category:            Editing+build-type:          Simple+extra-source-files:  ChangeLog.md+cabal-version:       >=1.10++executable ige+  main-is:             Main.hs+  other-modules:       IGE.Types+                     , IGE.Control+                     , IGE.Layout+                     , IGE.Render+                     , IGE.UI+                     , IGE.Keys+--                     , IGE.Lisp+                     , IGE.Serialization+  -- other-extensions:    +  build-depends:       base >= 4.9 && < 4.10+                     , cairo >= 0.13+                     , gtk >= 0.14+                     , protolude >= 0.1+                     , fgl+                     , microlens-platform +                     , linear+                     , containers+                     , conduit+                     , conduit-combinators+                     , stm-conduit+                     , stm-chans+                     , stm+                     , array+                     , mwc-random+                     , mtl+                     , transformers+                     , megaparsec+                     , text+                     , wl-pprint-text+                     , aeson+                     , bytestring+                     , directory++  default-extensions:  NoImplicitPrelude+                     , FlexibleContexts+                     , NoMonomorphismRestriction+                     , TypeFamilies+                     , GeneralizedNewtypeDeriving+                     , TemplateHaskell+                     , TypeSynonymInstances+                     , FlexibleInstances+                     , RankNTypes+                     , OverloadedStrings+  hs-source-dirs:      src+  default-language:    Haskell2010+  ghc-options:         -threaded++source-repository head+  type: git+  location: git://github.com/olynch/ige.git

@@ -0,0 +1,260 @@+module IGE.Control +  ( runKeyBinding+  , basicKeyBinding+  , textKeyBinding+  )+  where++import Prelude (String)+import Protolude hiding (empty, readFile, writeFile)+import qualified Data.Map.Strict as Map+import Lens.Micro.Platform+import Conduit+import Data.Conduit.TMChan+import Graphics.UI.Gtk hiding (get)+import Data.Graph.Inductive.Graph+import Data.Graph.Inductive.PatriciaTree+import Control.Concurrent.STM+import qualified Data.Sequence as Seq+import Data.Sequence ((<|), (|>), viewl, ViewL(..), Seq(..))+import Control.Monad.Trans.Maybe+import Data.Text (pack)+import Data.Aeson (ToJSON, FromJSON)+import Data.ByteString.Lazy (readFile, writeFile)+import System.Directory (doesFileExist)++import IGE.Types+import IGE.Keys+import IGE.Layout+import IGE.Serialization++navigationKeyMap :: Map.Map KeyVal (EditorM n e ())+navigationKeyMap = Map.fromList [+    (xK_plus, _rm . _at *= ((10/9) :+ 0))+  , (xK_minus, _rm . _at *= ((9/10) :+ 0))+  , (xK_h, transRel (0.5 :+ 0))+  , (xK_j, transRel (0 :+ (-0.5)))+  , (xK_k, transRel (0 :+ 0.5))+  , (xK_l, transRel ((-0.5) :+ 0))+  , (xK_greater, _rm . _at *= cis (pi / 6))+  , (xK_less, _rm . _at *= cis ((- pi) / 6))+  ]++transRel :: ℂ -> EditorM n e ()+transRel z = do+  r <- use $ _rm . _r+  _rm . _trans += (r :+ 0) * z+++awaitOrFinish :: (Monad m) => a -> (i -> ConduitM i o m a) -> ConduitM i o m a+awaitOrFinish x action = await >>= maybe (return x) action++updateEditor :: EditorM n e a -> KeyBinding n e a+updateEditor em = do+  x <- runTVarState em+  yield NoLayoutChange+  return x++updateEditorLayout :: EditorM n e a -> KeyBinding n e a+updateEditorLayout em = do+  x <- runTVarState em+  yield LayoutChange+  return x++tailButN :: Int -> [a] -> [a]+tailButN n xs = if length theTail < n then xs else theTail+  where theTail = tailDef [] xs++getString :: String -> KeyBinding n e (Maybe String)+getString init' = do+  updateEditor $ _cmd .= init+  loop+  where+    init = reverse init'+    n = length init+    handleInput kv+      | kv == xK_BackSpace = updateEditor (_cmd %= tailButN n) >> loop +      | kv == xK_Return = do+        s <- runTVarReader $ view _cmd+        updateEditor (_cmd .= "") >> return (Just $ drop n $ reverse s)+      | kv == xK_Escape = updateEditor (_cmd .= "") >> return Nothing+      | otherwise = loop++    loop = awaitOrFinish Nothing $ \kv -> +      case keyToChar kv of+        (Just c) -> updateEditor (_cmd %= (c:)) >> loop+        Nothing ->+          handleInput kv++labelChars = "asdfghjkl"++makeLabels :: Int -> String -> [String]+makeLabels n alphabet = helper n alphabet "" Seq.empty+  where+    helper :: Int -> String -> String -> Seq String -> [String]+    helper 0 _ _ queue = reverse <$> toList queue+    helper n (c:cs) postfix queue =+      helper (n - 1) cs postfix (queue |> (c:postfix))+    helper n [] _ queue =+      case viewl queue of+        a :< rest -> helper (n + 1) alphabet a rest+        EmptyL -> []++labelGraph :: Gr n e -> [(String, Node)]+labelGraph gr = zip labels (nodes gr)+  where+    labels = makeLabels (length $ nodes gr) labelChars++getNode :: KeyBinding n e (Maybe Node)+getNode = initLabels >> loop+  where+    initLabels = updateEditor $ do+      gr <- use _graph+      _labels .= labelGraph gr+    reset = updateEditor $ _labels .= []+    loop = awaitOrFinish Nothing $ \kv ->+      case keyToChar kv of+        (Just c) -> do+          labels <- runTVarReader $ view _labels+          let labels' = [(xs, node) | (x:xs, node) <- labels, x == c]+          case labels' of+            [] -> reset >> return Nothing+            [(_, node)] -> reset >> return (Just node)+            xs -> do+              updateEditor $ _labels .= labels'+              loop+        Nothing -> reset >> return Nothing++addNode :: KeyBinding () e ()+addNode =+  updateEditorLayout $ do +    n <- use _num+    _graph %= insNode (n, ())+    _num += 1++addNodeText :: KeyBinding Text e ()+addNodeText = do+  mlabel <- getString "label: "+  case mlabel of+    Just label -> updateEditorLayout $ do+      n <- use _num+      _graph %= insNode (n, pack label)+      _num += 1+    Nothing -> return ()+      +linkNodes :: KeyBinding n () ()+linkNodes = do+  mnodes <- runMaybeT $ do+    lift $ updateEditor $ _cmd .= reverse "SELECT NODE 1"+    n1 <- MaybeT getNode+    lift $ updateEditor $ _cmd .= reverse "SELECT NODE 2"+    n2 <- MaybeT getNode+    return (n1, n2)+  updateEditor $ _cmd .= ""+  case mnodes of+    Just (n1, n2) ->+      updateEditorLayout $ _graph %= insEdge (n1, n2, ())+    Nothing ->+      return ()++linkNodesText :: KeyBinding n Text ()+linkNodesText = do+  mnodes <- runMaybeT $ do+    lift $ updateEditor $ _cmd .= reverse "SELECT NODE 1"+    n1 <- MaybeT getNode+    lift $ updateEditor $ _cmd .= reverse "SELECT NODE 2"+    n2 <- MaybeT getNode+    label <- MaybeT $ getString "label: "+    return (n1, n2, label)+  case mnodes of+    Just (n1, n2, label) ->+      updateEditorLayout $ _graph %= insEdge (n1, n2, pack label)+    Nothing ->+      return ()++deleteNode :: KeyBinding n e ()+deleteNode = do+  mnode <- getNode+  case mnode of+    Just n -> updateEditor $ _graph %= delNode n+    Nothing -> return ()++readGraph :: (FromJSON n, FromJSON e) => KeyBinding n e ()+readGraph = do+  mnewgraph <- runMaybeT $ do+    filename <- MaybeT $ getString "filename: "+    liftIO (doesFileExist filename) >>= guard+    MaybeT $ graphFromBS <$> liftIO (readFile filename)+  case mnewgraph of+    Just newgraph ->+      updateEditorLayout $ _graph .= newgraph+    Nothing -> return ()+  +writeGraph :: (ToJSON n, ToJSON e) => KeyBinding n e ()+writeGraph = do+  mfilename <- getString "filename: "+  case mfilename of+    Just fn -> do+      g <- runTVarReader $ view _graph+      liftIO $ writeFile fn $ graphToBS g+    Nothing -> return ()++textKeyBinding :: KeyBinding Text Text ()+textKeyBinding = loop+  where+    loop = awaitOrFinish () $ \kv ->+      case Map.lookup kv navigationKeyMap of+        (Just em) -> do+          updateEditor em+          loop+        Nothing -> handleSpecial kv+    handleSpecial kv+      | kv == xK_colon = do+        cmd <- getString ":"+        print cmd+        loop+      | kv == xK_a = addNodeText >> loop+      | kv == xK_c = linkNodesText >> loop+      | kv == xK_d = deleteNode >> loop+      | kv == xK_w = writeGraph >> loop+      | kv == xK_o = readGraph >> loop+      | kv == xK_q = liftIO mainQuit >> return ()+      | otherwise = loop++basicKeyBinding :: KeyBinding () () ()+basicKeyBinding = loop+  where+    loop = awaitOrFinish () $ \kv ->+      case Map.lookup kv navigationKeyMap of+        (Just em) -> do+          updateEditor em+          loop+        Nothing -> handleSpecial kv+    handleSpecial kv+      | kv == xK_colon = do+        cmd <- getString ":"+        print cmd+        loop+      | kv == xK_a = addNode >> loop+      | kv == xK_c = linkNodes >> loop+      | kv == xK_d = deleteNode >> loop+      | kv == xK_q = liftIO mainQuit >> return ()+      | otherwise = loop++refresh :: (WidgetClass w) => w -> Consumer RefreshType (IGEM n e) ()+refresh widget = do+  rt <- await+  if rt == Just LayoutChange+    then runTVarState $ do+      graph <- use _graph+      _nodeMap .= layoutGr graph+    else return ()+  liftIO $ widgetQueueDraw widget+  refresh widget++runKeyBinding :: (WidgetClass w, RenderNode n, RenderEdge e) => TBMChan KeyVal -> TVar (EditorState n e) -> w -> KeyBinding n e () -> IO ()+runKeyBinding keyChan editorState w kb =+  runIGEM editorState $ runConduit $+      sourceTBMChan keyChan+   .| kb+   .| refresh w

@@ -0,0 +1,4544 @@+module IGE.Keys where++import Graphics.UI.Gtk (KeyVal)++xK_VoidSymbol :: KeyVal+xK_VoidSymbol = 0xffffff+xK_BackSpace :: KeyVal+xK_BackSpace = 0xff08+xK_Tab :: KeyVal+xK_Tab = 0xff09+xK_Linefeed :: KeyVal+xK_Linefeed = 0xff0a+xK_Clear :: KeyVal+xK_Clear = 0xff0b+xK_Return :: KeyVal+xK_Return = 0xff0d+xK_Pause :: KeyVal+xK_Pause = 0xff13+xK_Scroll_Lock :: KeyVal+xK_Scroll_Lock = 0xff14+xK_Sys_Req :: KeyVal+xK_Sys_Req = 0xff15+xK_Escape :: KeyVal+xK_Escape = 0xff1b+xK_Delete :: KeyVal+xK_Delete = 0xffff+xK_Multi_key :: KeyVal+xK_Multi_key = 0xff20+xK_Codeinput :: KeyVal+xK_Codeinput = 0xff37+xK_SingleCandidate :: KeyVal+xK_SingleCandidate = 0xff3c+xK_MultipleCandidate :: KeyVal+xK_MultipleCandidate = 0xff3d+xK_PreviousCandidate :: KeyVal+xK_PreviousCandidate = 0xff3e+xK_Kanji :: KeyVal+xK_Kanji = 0xff21+xK_Muhenkan :: KeyVal+xK_Muhenkan = 0xff22+xK_Henkan_Mode :: KeyVal+xK_Henkan_Mode = 0xff23+xK_Henkan :: KeyVal+xK_Henkan = 0xff23+xK_Romaji :: KeyVal+xK_Romaji = 0xff24+xK_Hiragana :: KeyVal+xK_Hiragana = 0xff25+xK_Katakana :: KeyVal+xK_Katakana = 0xff26+xK_Hiragana_Katakana :: KeyVal+xK_Hiragana_Katakana = 0xff27+xK_Zenkaku :: KeyVal+xK_Zenkaku = 0xff28+xK_Hankaku :: KeyVal+xK_Hankaku = 0xff29+xK_Zenkaku_Hankaku :: KeyVal+xK_Zenkaku_Hankaku = 0xff2a+xK_Touroku :: KeyVal+xK_Touroku = 0xff2b+xK_Massyo :: KeyVal+xK_Massyo = 0xff2c+xK_Kana_Lock :: KeyVal+xK_Kana_Lock = 0xff2d+xK_Kana_Shift :: KeyVal+xK_Kana_Shift = 0xff2e+xK_Eisu_Shift :: KeyVal+xK_Eisu_Shift = 0xff2f+xK_Eisu_toggle :: KeyVal+xK_Eisu_toggle = 0xff30+xK_Kanji_Bangou :: KeyVal+xK_Kanji_Bangou = 0xff37+xK_Zen_Koho :: KeyVal+xK_Zen_Koho = 0xff3d+xK_Mae_Koho :: KeyVal+xK_Mae_Koho = 0xff3e+xK_Home :: KeyVal+xK_Home = 0xff50+xK_Left :: KeyVal+xK_Left = 0xff51+xK_Up :: KeyVal+xK_Up = 0xff52+xK_Right :: KeyVal+xK_Right = 0xff53+xK_Down :: KeyVal+xK_Down = 0xff54+xK_Prior :: KeyVal+xK_Prior = 0xff55+xK_Page_Up :: KeyVal+xK_Page_Up = 0xff55+xK_Next :: KeyVal+xK_Next = 0xff56+xK_Page_Down :: KeyVal+xK_Page_Down = 0xff56+xK_End :: KeyVal+xK_End = 0xff57+xK_Begin :: KeyVal+xK_Begin = 0xff58+xK_Select :: KeyVal+xK_Select = 0xff60+xK_Print :: KeyVal+xK_Print = 0xff61+xK_Execute :: KeyVal+xK_Execute = 0xff62+xK_Insert :: KeyVal+xK_Insert = 0xff63+xK_Undo :: KeyVal+xK_Undo = 0xff65+xK_Redo :: KeyVal+xK_Redo = 0xff66+xK_Menu :: KeyVal+xK_Menu = 0xff67+xK_Find :: KeyVal+xK_Find = 0xff68+xK_Cancel :: KeyVal+xK_Cancel = 0xff69+xK_Help :: KeyVal+xK_Help = 0xff6a+xK_Break :: KeyVal+xK_Break = 0xff6b+xK_Mode_switch :: KeyVal+xK_Mode_switch = 0xff7e+xK_script_switch :: KeyVal+xK_script_switch = 0xff7e+xK_Num_Lock :: KeyVal+xK_Num_Lock = 0xff7f+xK_KP_Space :: KeyVal+xK_KP_Space = 0xff80+xK_KP_Tab :: KeyVal+xK_KP_Tab = 0xff89+xK_KP_Enter :: KeyVal+xK_KP_Enter = 0xff8d+xK_KP_F1 :: KeyVal+xK_KP_F1 = 0xff91+xK_KP_F2 :: KeyVal+xK_KP_F2 = 0xff92+xK_KP_F3 :: KeyVal+xK_KP_F3 = 0xff93+xK_KP_F4 :: KeyVal+xK_KP_F4 = 0xff94+xK_KP_Home :: KeyVal+xK_KP_Home = 0xff95+xK_KP_Left :: KeyVal+xK_KP_Left = 0xff96+xK_KP_Up :: KeyVal+xK_KP_Up = 0xff97+xK_KP_Right :: KeyVal+xK_KP_Right = 0xff98+xK_KP_Down :: KeyVal+xK_KP_Down = 0xff99+xK_KP_Prior :: KeyVal+xK_KP_Prior = 0xff9a+xK_KP_Page_Up :: KeyVal+xK_KP_Page_Up = 0xff9a+xK_KP_Next :: KeyVal+xK_KP_Next = 0xff9b+xK_KP_Page_Down :: KeyVal+xK_KP_Page_Down = 0xff9b+xK_KP_End :: KeyVal+xK_KP_End = 0xff9c+xK_KP_Begin :: KeyVal+xK_KP_Begin = 0xff9d+xK_KP_Insert :: KeyVal+xK_KP_Insert = 0xff9e+xK_KP_Delete :: KeyVal+xK_KP_Delete = 0xff9f+xK_KP_Equal :: KeyVal+xK_KP_Equal = 0xffbd+xK_KP_Multiply :: KeyVal+xK_KP_Multiply = 0xffaa+xK_KP_Add :: KeyVal+xK_KP_Add = 0xffab+xK_KP_Separator :: KeyVal+xK_KP_Separator = 0xffac+xK_KP_Subtract :: KeyVal+xK_KP_Subtract = 0xffad+xK_KP_Decimal :: KeyVal+xK_KP_Decimal = 0xffae+xK_KP_Divide :: KeyVal+xK_KP_Divide = 0xffaf+xK_KP_0 :: KeyVal+xK_KP_0 = 0xffb0+xK_KP_1 :: KeyVal+xK_KP_1 = 0xffb1+xK_KP_2 :: KeyVal+xK_KP_2 = 0xffb2+xK_KP_3 :: KeyVal+xK_KP_3 = 0xffb3+xK_KP_4 :: KeyVal+xK_KP_4 = 0xffb4+xK_KP_5 :: KeyVal+xK_KP_5 = 0xffb5+xK_KP_6 :: KeyVal+xK_KP_6 = 0xffb6+xK_KP_7 :: KeyVal+xK_KP_7 = 0xffb7+xK_KP_8 :: KeyVal+xK_KP_8 = 0xffb8+xK_KP_9 :: KeyVal+xK_KP_9 = 0xffb9+xK_F1 :: KeyVal+xK_F1 = 0xffbe+xK_F2 :: KeyVal+xK_F2 = 0xffbf+xK_F3 :: KeyVal+xK_F3 = 0xffc0+xK_F4 :: KeyVal+xK_F4 = 0xffc1+xK_F5 :: KeyVal+xK_F5 = 0xffc2+xK_F6 :: KeyVal+xK_F6 = 0xffc3+xK_F7 :: KeyVal+xK_F7 = 0xffc4+xK_F8 :: KeyVal+xK_F8 = 0xffc5+xK_F9 :: KeyVal+xK_F9 = 0xffc6+xK_F10 :: KeyVal+xK_F10 = 0xffc7+xK_F11 :: KeyVal+xK_F11 = 0xffc8+xK_L1 :: KeyVal+xK_L1 = 0xffc8+xK_F12 :: KeyVal+xK_F12 = 0xffc9+xK_L2 :: KeyVal+xK_L2 = 0xffc9+xK_F13 :: KeyVal+xK_F13 = 0xffca+xK_L3 :: KeyVal+xK_L3 = 0xffca+xK_F14 :: KeyVal+xK_F14 = 0xffcb+xK_L4 :: KeyVal+xK_L4 = 0xffcb+xK_F15 :: KeyVal+xK_F15 = 0xffcc+xK_L5 :: KeyVal+xK_L5 = 0xffcc+xK_F16 :: KeyVal+xK_F16 = 0xffcd+xK_L6 :: KeyVal+xK_L6 = 0xffcd+xK_F17 :: KeyVal+xK_F17 = 0xffce+xK_L7 :: KeyVal+xK_L7 = 0xffce+xK_F18 :: KeyVal+xK_F18 = 0xffcf+xK_L8 :: KeyVal+xK_L8 = 0xffcf+xK_F19 :: KeyVal+xK_F19 = 0xffd0+xK_L9 :: KeyVal+xK_L9 = 0xffd0+xK_F20 :: KeyVal+xK_F20 = 0xffd1+xK_L10 :: KeyVal+xK_L10 = 0xffd1+xK_F21 :: KeyVal+xK_F21 = 0xffd2+xK_R1 :: KeyVal+xK_R1 = 0xffd2+xK_F22 :: KeyVal+xK_F22 = 0xffd3+xK_R2 :: KeyVal+xK_R2 = 0xffd3+xK_F23 :: KeyVal+xK_F23 = 0xffd4+xK_R3 :: KeyVal+xK_R3 = 0xffd4+xK_F24 :: KeyVal+xK_F24 = 0xffd5+xK_R4 :: KeyVal+xK_R4 = 0xffd5+xK_F25 :: KeyVal+xK_F25 = 0xffd6+xK_R5 :: KeyVal+xK_R5 = 0xffd6+xK_F26 :: KeyVal+xK_F26 = 0xffd7+xK_R6 :: KeyVal+xK_R6 = 0xffd7+xK_F27 :: KeyVal+xK_F27 = 0xffd8+xK_R7 :: KeyVal+xK_R7 = 0xffd8+xK_F28 :: KeyVal+xK_F28 = 0xffd9+xK_R8 :: KeyVal+xK_R8 = 0xffd9+xK_F29 :: KeyVal+xK_F29 = 0xffda+xK_R9 :: KeyVal+xK_R9 = 0xffda+xK_F30 :: KeyVal+xK_F30 = 0xffdb+xK_R10 :: KeyVal+xK_R10 = 0xffdb+xK_F31 :: KeyVal+xK_F31 = 0xffdc+xK_R11 :: KeyVal+xK_R11 = 0xffdc+xK_F32 :: KeyVal+xK_F32 = 0xffdd+xK_R12 :: KeyVal+xK_R12 = 0xffdd+xK_F33 :: KeyVal+xK_F33 = 0xffde+xK_R13 :: KeyVal+xK_R13 = 0xffde+xK_F34 :: KeyVal+xK_F34 = 0xffdf+xK_R14 :: KeyVal+xK_R14 = 0xffdf+xK_F35 :: KeyVal+xK_F35 = 0xffe0+xK_R15 :: KeyVal+xK_R15 = 0xffe0+xK_Shift_L :: KeyVal+xK_Shift_L = 0xffe1+xK_Shift_R :: KeyVal+xK_Shift_R = 0xffe2+xK_Control_L :: KeyVal+xK_Control_L = 0xffe3+xK_Control_R :: KeyVal+xK_Control_R = 0xffe4+xK_Caps_Lock :: KeyVal+xK_Caps_Lock = 0xffe5+xK_Shift_Lock :: KeyVal+xK_Shift_Lock = 0xffe6+xK_Meta_L :: KeyVal+xK_Meta_L = 0xffe7+xK_Meta_R :: KeyVal+xK_Meta_R = 0xffe8+xK_Alt_L :: KeyVal+xK_Alt_L = 0xffe9+xK_Alt_R :: KeyVal+xK_Alt_R = 0xffea+xK_Super_L :: KeyVal+xK_Super_L = 0xffeb+xK_Super_R :: KeyVal+xK_Super_R = 0xffec+xK_Hyper_L :: KeyVal+xK_Hyper_L = 0xffed+xK_Hyper_R :: KeyVal+xK_Hyper_R = 0xffee+xK_ISO_Lock :: KeyVal+xK_ISO_Lock = 0xfe01+xK_ISO_Level2_Latch :: KeyVal+xK_ISO_Level2_Latch = 0xfe02+xK_ISO_Level3_Shift :: KeyVal+xK_ISO_Level3_Shift = 0xfe03+xK_ISO_Level3_Latch :: KeyVal+xK_ISO_Level3_Latch = 0xfe04+xK_ISO_Level3_Lock :: KeyVal+xK_ISO_Level3_Lock = 0xfe05+xK_ISO_Level5_Shift :: KeyVal+xK_ISO_Level5_Shift = 0xfe11+xK_ISO_Level5_Latch :: KeyVal+xK_ISO_Level5_Latch = 0xfe12+xK_ISO_Level5_Lock :: KeyVal+xK_ISO_Level5_Lock = 0xfe13+xK_ISO_Group_Shift :: KeyVal+xK_ISO_Group_Shift = 0xff7e+xK_ISO_Group_Latch :: KeyVal+xK_ISO_Group_Latch = 0xfe06+xK_ISO_Group_Lock :: KeyVal+xK_ISO_Group_Lock = 0xfe07+xK_ISO_Next_Group :: KeyVal+xK_ISO_Next_Group = 0xfe08+xK_ISO_Next_Group_Lock :: KeyVal+xK_ISO_Next_Group_Lock = 0xfe09+xK_ISO_Prev_Group :: KeyVal+xK_ISO_Prev_Group = 0xfe0a+xK_ISO_Prev_Group_Lock :: KeyVal+xK_ISO_Prev_Group_Lock = 0xfe0b+xK_ISO_First_Group :: KeyVal+xK_ISO_First_Group = 0xfe0c+xK_ISO_First_Group_Lock :: KeyVal+xK_ISO_First_Group_Lock = 0xfe0d+xK_ISO_Last_Group :: KeyVal+xK_ISO_Last_Group = 0xfe0e+xK_ISO_Last_Group_Lock :: KeyVal+xK_ISO_Last_Group_Lock = 0xfe0f+xK_ISO_Left_Tab :: KeyVal+xK_ISO_Left_Tab = 0xfe20+xK_ISO_Move_Line_Up :: KeyVal+xK_ISO_Move_Line_Up = 0xfe21+xK_ISO_Move_Line_Down :: KeyVal+xK_ISO_Move_Line_Down = 0xfe22+xK_ISO_Partial_Line_Up :: KeyVal+xK_ISO_Partial_Line_Up = 0xfe23+xK_ISO_Partial_Line_Down :: KeyVal+xK_ISO_Partial_Line_Down = 0xfe24+xK_ISO_Partial_Space_Left :: KeyVal+xK_ISO_Partial_Space_Left = 0xfe25+xK_ISO_Partial_Space_Right :: KeyVal+xK_ISO_Partial_Space_Right = 0xfe26+xK_ISO_Set_Margin_Left :: KeyVal+xK_ISO_Set_Margin_Left = 0xfe27+xK_ISO_Set_Margin_Right :: KeyVal+xK_ISO_Set_Margin_Right = 0xfe28+xK_ISO_Release_Margin_Left :: KeyVal+xK_ISO_Release_Margin_Left = 0xfe29+xK_ISO_Release_Margin_Right :: KeyVal+xK_ISO_Release_Margin_Right = 0xfe2a+xK_ISO_Release_Both_Margins :: KeyVal+xK_ISO_Release_Both_Margins = 0xfe2b+xK_ISO_Fast_Cursor_Left :: KeyVal+xK_ISO_Fast_Cursor_Left = 0xfe2c+xK_ISO_Fast_Cursor_Right :: KeyVal+xK_ISO_Fast_Cursor_Right = 0xfe2d+xK_ISO_Fast_Cursor_Up :: KeyVal+xK_ISO_Fast_Cursor_Up = 0xfe2e+xK_ISO_Fast_Cursor_Down :: KeyVal+xK_ISO_Fast_Cursor_Down = 0xfe2f+xK_ISO_Continuous_Underline :: KeyVal+xK_ISO_Continuous_Underline = 0xfe30+xK_ISO_Discontinuous_Underline :: KeyVal+xK_ISO_Discontinuous_Underline = 0xfe31+xK_ISO_Emphasize :: KeyVal+xK_ISO_Emphasize = 0xfe32+xK_ISO_Center_Object :: KeyVal+xK_ISO_Center_Object = 0xfe33+xK_ISO_Enter :: KeyVal+xK_ISO_Enter = 0xfe34+xK_dead_grave :: KeyVal+xK_dead_grave = 0xfe50+xK_dead_acute :: KeyVal+xK_dead_acute = 0xfe51+xK_dead_circumflex :: KeyVal+xK_dead_circumflex = 0xfe52+xK_dead_tilde :: KeyVal+xK_dead_tilde = 0xfe53+xK_dead_perispomeni :: KeyVal+xK_dead_perispomeni = 0xfe53+xK_dead_macron :: KeyVal+xK_dead_macron = 0xfe54+xK_dead_breve :: KeyVal+xK_dead_breve = 0xfe55+xK_dead_abovedot :: KeyVal+xK_dead_abovedot = 0xfe56+xK_dead_diaeresis :: KeyVal+xK_dead_diaeresis = 0xfe57+xK_dead_abovering :: KeyVal+xK_dead_abovering = 0xfe58+xK_dead_doubleacute :: KeyVal+xK_dead_doubleacute = 0xfe59+xK_dead_caron :: KeyVal+xK_dead_caron = 0xfe5a+xK_dead_cedilla :: KeyVal+xK_dead_cedilla = 0xfe5b+xK_dead_ogonek :: KeyVal+xK_dead_ogonek = 0xfe5c+xK_dead_iota :: KeyVal+xK_dead_iota = 0xfe5d+xK_dead_voiced_sound :: KeyVal+xK_dead_voiced_sound = 0xfe5e+xK_dead_semivoiced_sound :: KeyVal+xK_dead_semivoiced_sound = 0xfe5f+xK_dead_belowdot :: KeyVal+xK_dead_belowdot = 0xfe60+xK_dead_hook :: KeyVal+xK_dead_hook = 0xfe61+xK_dead_horn :: KeyVal+xK_dead_horn = 0xfe62+xK_dead_stroke :: KeyVal+xK_dead_stroke = 0xfe63+xK_dead_abovecomma :: KeyVal+xK_dead_abovecomma = 0xfe64+xK_dead_psili :: KeyVal+xK_dead_psili = 0xfe64+xK_dead_abovereversedcomma :: KeyVal+xK_dead_abovereversedcomma = 0xfe65+xK_dead_dasia :: KeyVal+xK_dead_dasia = 0xfe65+xK_dead_doublegrave :: KeyVal+xK_dead_doublegrave = 0xfe66+xK_dead_belowring :: KeyVal+xK_dead_belowring = 0xfe67+xK_dead_belowmacron :: KeyVal+xK_dead_belowmacron = 0xfe68+xK_dead_belowcircumflex :: KeyVal+xK_dead_belowcircumflex = 0xfe69+xK_dead_belowtilde :: KeyVal+xK_dead_belowtilde = 0xfe6a+xK_dead_belowbreve :: KeyVal+xK_dead_belowbreve = 0xfe6b+xK_dead_belowdiaeresis :: KeyVal+xK_dead_belowdiaeresis = 0xfe6c+xK_dead_invertedbreve :: KeyVal+xK_dead_invertedbreve = 0xfe6d+xK_dead_belowcomma :: KeyVal+xK_dead_belowcomma = 0xfe6e+xK_dead_currency :: KeyVal+xK_dead_currency = 0xfe6f+xK_dead_a :: KeyVal+xK_dead_a = 0xfe80+xK_dead_A :: KeyVal+xK_dead_A = 0xfe81+xK_dead_e :: KeyVal+xK_dead_e = 0xfe82+xK_dead_E :: KeyVal+xK_dead_E = 0xfe83+xK_dead_i :: KeyVal+xK_dead_i = 0xfe84+xK_dead_I :: KeyVal+xK_dead_I = 0xfe85+xK_dead_o :: KeyVal+xK_dead_o = 0xfe86+xK_dead_O :: KeyVal+xK_dead_O = 0xfe87+xK_dead_u :: KeyVal+xK_dead_u = 0xfe88+xK_dead_U :: KeyVal+xK_dead_U = 0xfe89+xK_dead_small_schwa :: KeyVal+xK_dead_small_schwa = 0xfe8a+xK_dead_capital_schwa :: KeyVal+xK_dead_capital_schwa = 0xfe8b+xK_dead_greek :: KeyVal+xK_dead_greek = 0xfe8c+xK_First_Virtual_Screen :: KeyVal+xK_First_Virtual_Screen = 0xfed0+xK_Prev_Virtual_Screen :: KeyVal+xK_Prev_Virtual_Screen = 0xfed1+xK_Next_Virtual_Screen :: KeyVal+xK_Next_Virtual_Screen = 0xfed2+xK_Last_Virtual_Screen :: KeyVal+xK_Last_Virtual_Screen = 0xfed4+xK_Terminate_Server :: KeyVal+xK_Terminate_Server = 0xfed5+xK_AccessX_Enable :: KeyVal+xK_AccessX_Enable = 0xfe70+xK_AccessX_Feedback_Enable :: KeyVal+xK_AccessX_Feedback_Enable = 0xfe71+xK_RepeatKeys_Enable :: KeyVal+xK_RepeatKeys_Enable = 0xfe72+xK_SlowKeys_Enable :: KeyVal+xK_SlowKeys_Enable = 0xfe73+xK_BounceKeys_Enable :: KeyVal+xK_BounceKeys_Enable = 0xfe74+xK_StickyKeys_Enable :: KeyVal+xK_StickyKeys_Enable = 0xfe75+xK_MouseKeys_Enable :: KeyVal+xK_MouseKeys_Enable = 0xfe76+xK_MouseKeys_Accel_Enable :: KeyVal+xK_MouseKeys_Accel_Enable = 0xfe77+xK_Overlay1_Enable :: KeyVal+xK_Overlay1_Enable = 0xfe78+xK_Overlay2_Enable :: KeyVal+xK_Overlay2_Enable = 0xfe79+xK_AudibleBell_Enable :: KeyVal+xK_AudibleBell_Enable = 0xfe7a+xK_Pointer_Left :: KeyVal+xK_Pointer_Left = 0xfee0+xK_Pointer_Right :: KeyVal+xK_Pointer_Right = 0xfee1+xK_Pointer_Up :: KeyVal+xK_Pointer_Up = 0xfee2+xK_Pointer_Down :: KeyVal+xK_Pointer_Down = 0xfee3+xK_Pointer_UpLeft :: KeyVal+xK_Pointer_UpLeft = 0xfee4+xK_Pointer_UpRight :: KeyVal+xK_Pointer_UpRight = 0xfee5+xK_Pointer_DownLeft :: KeyVal+xK_Pointer_DownLeft = 0xfee6+xK_Pointer_DownRight :: KeyVal+xK_Pointer_DownRight = 0xfee7+xK_Pointer_Button_Dflt :: KeyVal+xK_Pointer_Button_Dflt = 0xfee8+xK_Pointer_Button1 :: KeyVal+xK_Pointer_Button1 = 0xfee9+xK_Pointer_Button2 :: KeyVal+xK_Pointer_Button2 = 0xfeea+xK_Pointer_Button3 :: KeyVal+xK_Pointer_Button3 = 0xfeeb+xK_Pointer_Button4 :: KeyVal+xK_Pointer_Button4 = 0xfeec+xK_Pointer_Button5 :: KeyVal+xK_Pointer_Button5 = 0xfeed+xK_Pointer_DblClick_Dflt :: KeyVal+xK_Pointer_DblClick_Dflt = 0xfeee+xK_Pointer_DblClick1 :: KeyVal+xK_Pointer_DblClick1 = 0xfeef+xK_Pointer_DblClick2 :: KeyVal+xK_Pointer_DblClick2 = 0xfef0+xK_Pointer_DblClick3 :: KeyVal+xK_Pointer_DblClick3 = 0xfef1+xK_Pointer_DblClick4 :: KeyVal+xK_Pointer_DblClick4 = 0xfef2+xK_Pointer_DblClick5 :: KeyVal+xK_Pointer_DblClick5 = 0xfef3+xK_Pointer_Drag_Dflt :: KeyVal+xK_Pointer_Drag_Dflt = 0xfef4+xK_Pointer_Drag1 :: KeyVal+xK_Pointer_Drag1 = 0xfef5+xK_Pointer_Drag2 :: KeyVal+xK_Pointer_Drag2 = 0xfef6+xK_Pointer_Drag3 :: KeyVal+xK_Pointer_Drag3 = 0xfef7+xK_Pointer_Drag4 :: KeyVal+xK_Pointer_Drag4 = 0xfef8+xK_Pointer_Drag5 :: KeyVal+xK_Pointer_Drag5 = 0xfefd+xK_Pointer_EnableKeys :: KeyVal+xK_Pointer_EnableKeys = 0xfef9+xK_Pointer_Accelerate :: KeyVal+xK_Pointer_Accelerate = 0xfefa+xK_Pointer_DfltBtnNext :: KeyVal+xK_Pointer_DfltBtnNext = 0xfefb+xK_Pointer_DfltBtnPrev :: KeyVal+xK_Pointer_DfltBtnPrev = 0xfefc+xK_ch :: KeyVal+xK_ch = 0xfea0+xK_Ch :: KeyVal+xK_Ch = 0xfea1+xK_CH :: KeyVal+xK_CH = 0xfea2+xK_c_h :: KeyVal+xK_c_h = 0xfea3+xK_C_h :: KeyVal+xK_C_h = 0xfea4+xK_C_H :: KeyVal+xK_C_H = 0xfea5+xK_3270_Duplicate :: KeyVal+xK_3270_Duplicate = 0xfd01+xK_3270_FieldMark :: KeyVal+xK_3270_FieldMark = 0xfd02+xK_3270_Right2 :: KeyVal+xK_3270_Right2 = 0xfd03+xK_3270_Left2 :: KeyVal+xK_3270_Left2 = 0xfd04+xK_3270_BackTab :: KeyVal+xK_3270_BackTab = 0xfd05+xK_3270_EraseEOF :: KeyVal+xK_3270_EraseEOF = 0xfd06+xK_3270_EraseInput :: KeyVal+xK_3270_EraseInput = 0xfd07+xK_3270_Reset :: KeyVal+xK_3270_Reset = 0xfd08+xK_3270_Quit :: KeyVal+xK_3270_Quit = 0xfd09+xK_3270_PA1 :: KeyVal+xK_3270_PA1 = 0xfd0a+xK_3270_PA2 :: KeyVal+xK_3270_PA2 = 0xfd0b+xK_3270_PA3 :: KeyVal+xK_3270_PA3 = 0xfd0c+xK_3270_Test :: KeyVal+xK_3270_Test = 0xfd0d+xK_3270_Attn :: KeyVal+xK_3270_Attn = 0xfd0e+xK_3270_CursorBlink :: KeyVal+xK_3270_CursorBlink = 0xfd0f+xK_3270_AltCursor :: KeyVal+xK_3270_AltCursor = 0xfd10+xK_3270_KeyClick :: KeyVal+xK_3270_KeyClick = 0xfd11+xK_3270_Jump :: KeyVal+xK_3270_Jump = 0xfd12+xK_3270_Ident :: KeyVal+xK_3270_Ident = 0xfd13+xK_3270_Rule :: KeyVal+xK_3270_Rule = 0xfd14+xK_3270_Copy :: KeyVal+xK_3270_Copy = 0xfd15+xK_3270_Play :: KeyVal+xK_3270_Play = 0xfd16+xK_3270_Setup :: KeyVal+xK_3270_Setup = 0xfd17+xK_3270_Record :: KeyVal+xK_3270_Record = 0xfd18+xK_3270_ChangeScreen :: KeyVal+xK_3270_ChangeScreen = 0xfd19+xK_3270_DeleteWord :: KeyVal+xK_3270_DeleteWord = 0xfd1a+xK_3270_ExSelect :: KeyVal+xK_3270_ExSelect = 0xfd1b+xK_3270_CursorSelect :: KeyVal+xK_3270_CursorSelect = 0xfd1c+xK_3270_PrintScreen :: KeyVal+xK_3270_PrintScreen = 0xfd1d+xK_3270_Enter :: KeyVal+xK_3270_Enter = 0xfd1e+xK_space :: KeyVal+xK_space = 0x020+xK_exclam :: KeyVal+xK_exclam = 0x021+xK_quotedbl :: KeyVal+xK_quotedbl = 0x022+xK_numbersign :: KeyVal+xK_numbersign = 0x023+xK_dollar :: KeyVal+xK_dollar = 0x024+xK_percent :: KeyVal+xK_percent = 0x025+xK_ampersand :: KeyVal+xK_ampersand = 0x026+xK_apostrophe :: KeyVal+xK_apostrophe = 0x027+xK_quoteright :: KeyVal+xK_quoteright = 0x027+xK_parenleft :: KeyVal+xK_parenleft = 0x028+xK_parenright :: KeyVal+xK_parenright = 0x029+xK_asterisk :: KeyVal+xK_asterisk = 0x02a+xK_plus :: KeyVal+xK_plus = 0x02b+xK_comma :: KeyVal+xK_comma = 0x02c+xK_minus :: KeyVal+xK_minus = 0x02d+xK_period :: KeyVal+xK_period = 0x02e+xK_slash :: KeyVal+xK_slash = 0x02f+xK_0 :: KeyVal+xK_0 = 0x030+xK_1 :: KeyVal+xK_1 = 0x031+xK_2 :: KeyVal+xK_2 = 0x032+xK_3 :: KeyVal+xK_3 = 0x033+xK_4 :: KeyVal+xK_4 = 0x034+xK_5 :: KeyVal+xK_5 = 0x035+xK_6 :: KeyVal+xK_6 = 0x036+xK_7 :: KeyVal+xK_7 = 0x037+xK_8 :: KeyVal+xK_8 = 0x038+xK_9 :: KeyVal+xK_9 = 0x039+xK_colon :: KeyVal+xK_colon = 0x03a+xK_semicolon :: KeyVal+xK_semicolon = 0x03b+xK_less :: KeyVal+xK_less = 0x03c+xK_equal :: KeyVal+xK_equal = 0x03d+xK_greater :: KeyVal+xK_greater = 0x03e+xK_question :: KeyVal+xK_question = 0x03f+xK_at :: KeyVal+xK_at = 0x040+xK_A :: KeyVal+xK_A = 0x041+xK_B :: KeyVal+xK_B = 0x042+xK_C :: KeyVal+xK_C = 0x043+xK_D :: KeyVal+xK_D = 0x044+xK_E :: KeyVal+xK_E = 0x045+xK_F :: KeyVal+xK_F = 0x046+xK_G :: KeyVal+xK_G = 0x047+xK_H :: KeyVal+xK_H = 0x048+xK_I :: KeyVal+xK_I = 0x049+xK_J :: KeyVal+xK_J = 0x04a+xK_K :: KeyVal+xK_K = 0x04b+xK_L :: KeyVal+xK_L = 0x04c+xK_M :: KeyVal+xK_M = 0x04d+xK_N :: KeyVal+xK_N = 0x04e+xK_O :: KeyVal+xK_O = 0x04f+xK_P :: KeyVal+xK_P = 0x050+xK_Q :: KeyVal+xK_Q = 0x051+xK_R :: KeyVal+xK_R = 0x052+xK_S :: KeyVal+xK_S = 0x053+xK_T :: KeyVal+xK_T = 0x054+xK_U :: KeyVal+xK_U = 0x055+xK_V :: KeyVal+xK_V = 0x056+xK_W :: KeyVal+xK_W = 0x057+xK_X :: KeyVal+xK_X = 0x058+xK_Y :: KeyVal+xK_Y = 0x059+xK_Z :: KeyVal+xK_Z = 0x05a+xK_bracketleft :: KeyVal+xK_bracketleft = 0x05b+xK_backslash :: KeyVal+xK_backslash = 0x05c+xK_bracketright :: KeyVal+xK_bracketright = 0x05d+xK_asciicircum :: KeyVal+xK_asciicircum = 0x05e+xK_underscore :: KeyVal+xK_underscore = 0x05f+xK_grave :: KeyVal+xK_grave = 0x060+xK_quoteleft :: KeyVal+xK_quoteleft = 0x060+xK_a :: KeyVal+xK_a = 0x061+xK_b :: KeyVal+xK_b = 0x062+xK_c :: KeyVal+xK_c = 0x063+xK_d :: KeyVal+xK_d = 0x064+xK_e :: KeyVal+xK_e = 0x065+xK_f :: KeyVal+xK_f = 0x066+xK_g :: KeyVal+xK_g = 0x067+xK_h :: KeyVal+xK_h = 0x068+xK_i :: KeyVal+xK_i = 0x069+xK_j :: KeyVal+xK_j = 0x06a+xK_k :: KeyVal+xK_k = 0x06b+xK_l :: KeyVal+xK_l = 0x06c+xK_m :: KeyVal+xK_m = 0x06d+xK_n :: KeyVal+xK_n = 0x06e+xK_o :: KeyVal+xK_o = 0x06f+xK_p :: KeyVal+xK_p = 0x070+xK_q :: KeyVal+xK_q = 0x071+xK_r :: KeyVal+xK_r = 0x072+xK_s :: KeyVal+xK_s = 0x073+xK_t :: KeyVal+xK_t = 0x074+xK_u :: KeyVal+xK_u = 0x075+xK_v :: KeyVal+xK_v = 0x076+xK_w :: KeyVal+xK_w = 0x077+xK_x :: KeyVal+xK_x = 0x078+xK_y :: KeyVal+xK_y = 0x079+xK_z :: KeyVal+xK_z = 0x07a+xK_braceleft :: KeyVal+xK_braceleft = 0x07b+xK_bar :: KeyVal+xK_bar = 0x07c+xK_braceright :: KeyVal+xK_braceright = 0x07d+xK_asciitilde :: KeyVal+xK_asciitilde = 0x07e+xK_nobreakspace :: KeyVal+xK_nobreakspace = 0x0a0+xK_exclamdown :: KeyVal+xK_exclamdown = 0x0a1+xK_cent :: KeyVal+xK_cent = 0x0a2+xK_sterling :: KeyVal+xK_sterling = 0x0a3+xK_currency :: KeyVal+xK_currency = 0x0a4+xK_yen :: KeyVal+xK_yen = 0x0a5+xK_brokenbar :: KeyVal+xK_brokenbar = 0x0a6+xK_section :: KeyVal+xK_section = 0x0a7+xK_diaeresis :: KeyVal+xK_diaeresis = 0x0a8+xK_copyright :: KeyVal+xK_copyright = 0x0a9+xK_ordfeminine :: KeyVal+xK_ordfeminine = 0x0aa+xK_guillemotleft :: KeyVal+xK_guillemotleft = 0x0ab+xK_notsign :: KeyVal+xK_notsign = 0x0ac+xK_hyphen :: KeyVal+xK_hyphen = 0x0ad+xK_registered :: KeyVal+xK_registered = 0x0ae+xK_macron :: KeyVal+xK_macron = 0x0af+xK_degree :: KeyVal+xK_degree = 0x0b0+xK_plusminus :: KeyVal+xK_plusminus = 0x0b1+xK_twosuperior :: KeyVal+xK_twosuperior = 0x0b2+xK_threesuperior :: KeyVal+xK_threesuperior = 0x0b3+xK_acute :: KeyVal+xK_acute = 0x0b4+xK_mu :: KeyVal+xK_mu = 0x0b5+xK_paragraph :: KeyVal+xK_paragraph = 0x0b6+xK_periodcentered :: KeyVal+xK_periodcentered = 0x0b7+xK_cedilla :: KeyVal+xK_cedilla = 0x0b8+xK_onesuperior :: KeyVal+xK_onesuperior = 0x0b9+xK_masculine :: KeyVal+xK_masculine = 0x0ba+xK_guillemotright :: KeyVal+xK_guillemotright = 0x0bb+xK_onequarter :: KeyVal+xK_onequarter = 0x0bc+xK_onehalf :: KeyVal+xK_onehalf = 0x0bd+xK_threequarters :: KeyVal+xK_threequarters = 0x0be+xK_questiondown :: KeyVal+xK_questiondown = 0x0bf+xK_Agrave :: KeyVal+xK_Agrave = 0x0c0+xK_Aacute :: KeyVal+xK_Aacute = 0x0c1+xK_Acircumflex :: KeyVal+xK_Acircumflex = 0x0c2+xK_Atilde :: KeyVal+xK_Atilde = 0x0c3+xK_Adiaeresis :: KeyVal+xK_Adiaeresis = 0x0c4+xK_Aring :: KeyVal+xK_Aring = 0x0c5+xK_AE :: KeyVal+xK_AE = 0x0c6+xK_Ccedilla :: KeyVal+xK_Ccedilla = 0x0c7+xK_Egrave :: KeyVal+xK_Egrave = 0x0c8+xK_Eacute :: KeyVal+xK_Eacute = 0x0c9+xK_Ecircumflex :: KeyVal+xK_Ecircumflex = 0x0ca+xK_Ediaeresis :: KeyVal+xK_Ediaeresis = 0x0cb+xK_Igrave :: KeyVal+xK_Igrave = 0x0cc+xK_Iacute :: KeyVal+xK_Iacute = 0x0cd+xK_Icircumflex :: KeyVal+xK_Icircumflex = 0x0ce+xK_Idiaeresis :: KeyVal+xK_Idiaeresis = 0x0cf+xK_ETH :: KeyVal+xK_ETH = 0x0d0+xK_Eth :: KeyVal+xK_Eth = 0x0d0+xK_Ntilde :: KeyVal+xK_Ntilde = 0x0d1+xK_Ograve :: KeyVal+xK_Ograve = 0x0d2+xK_Oacute :: KeyVal+xK_Oacute = 0x0d3+xK_Ocircumflex :: KeyVal+xK_Ocircumflex = 0x0d4+xK_Otilde :: KeyVal+xK_Otilde = 0x0d5+xK_Odiaeresis :: KeyVal+xK_Odiaeresis = 0x0d6+xK_multiply :: KeyVal+xK_multiply = 0x0d7+xK_Oslash :: KeyVal+xK_Oslash = 0x0d8+xK_Ooblique :: KeyVal+xK_Ooblique = 0x0d8+xK_Ugrave :: KeyVal+xK_Ugrave = 0x0d9+xK_Uacute :: KeyVal+xK_Uacute = 0x0da+xK_Ucircumflex :: KeyVal+xK_Ucircumflex = 0x0db+xK_Udiaeresis :: KeyVal+xK_Udiaeresis = 0x0dc+xK_Yacute :: KeyVal+xK_Yacute = 0x0dd+xK_THORN :: KeyVal+xK_THORN = 0x0de+xK_Thorn :: KeyVal+xK_Thorn = 0x0de+xK_ssharp :: KeyVal+xK_ssharp = 0x0df+xK_agrave :: KeyVal+xK_agrave = 0x0e0+xK_aacute :: KeyVal+xK_aacute = 0x0e1+xK_acircumflex :: KeyVal+xK_acircumflex = 0x0e2+xK_atilde :: KeyVal+xK_atilde = 0x0e3+xK_adiaeresis :: KeyVal+xK_adiaeresis = 0x0e4+xK_aring :: KeyVal+xK_aring = 0x0e5+xK_ae :: KeyVal+xK_ae = 0x0e6+xK_ccedilla :: KeyVal+xK_ccedilla = 0x0e7+xK_egrave :: KeyVal+xK_egrave = 0x0e8+xK_eacute :: KeyVal+xK_eacute = 0x0e9+xK_ecircumflex :: KeyVal+xK_ecircumflex = 0x0ea+xK_ediaeresis :: KeyVal+xK_ediaeresis = 0x0eb+xK_igrave :: KeyVal+xK_igrave = 0x0ec+xK_iacute :: KeyVal+xK_iacute = 0x0ed+xK_icircumflex :: KeyVal+xK_icircumflex = 0x0ee+xK_idiaeresis :: KeyVal+xK_idiaeresis = 0x0ef+xK_eth :: KeyVal+xK_eth = 0x0f0+xK_ntilde :: KeyVal+xK_ntilde = 0x0f1+xK_ograve :: KeyVal+xK_ograve = 0x0f2+xK_oacute :: KeyVal+xK_oacute = 0x0f3+xK_ocircumflex :: KeyVal+xK_ocircumflex = 0x0f4+xK_otilde :: KeyVal+xK_otilde = 0x0f5+xK_odiaeresis :: KeyVal+xK_odiaeresis = 0x0f6+xK_division :: KeyVal+xK_division = 0x0f7+xK_oslash :: KeyVal+xK_oslash = 0x0f8+xK_ooblique :: KeyVal+xK_ooblique = 0x0f8+xK_ugrave :: KeyVal+xK_ugrave = 0x0f9+xK_uacute :: KeyVal+xK_uacute = 0x0fa+xK_ucircumflex :: KeyVal+xK_ucircumflex = 0x0fb+xK_udiaeresis :: KeyVal+xK_udiaeresis = 0x0fc+xK_yacute :: KeyVal+xK_yacute = 0x0fd+xK_thorn :: KeyVal+xK_thorn = 0x0fe+xK_ydiaeresis :: KeyVal+xK_ydiaeresis = 0x0ff+xK_Aogonek :: KeyVal+xK_Aogonek = 0x1a1+xK_breve :: KeyVal+xK_breve = 0x1a2+xK_Lstroke :: KeyVal+xK_Lstroke = 0x1a3+xK_Lcaron :: KeyVal+xK_Lcaron = 0x1a5+xK_Sacute :: KeyVal+xK_Sacute = 0x1a6+xK_Scaron :: KeyVal+xK_Scaron = 0x1a9+xK_Scedilla :: KeyVal+xK_Scedilla = 0x1aa+xK_Tcaron :: KeyVal+xK_Tcaron = 0x1ab+xK_Zacute :: KeyVal+xK_Zacute = 0x1ac+xK_Zcaron :: KeyVal+xK_Zcaron = 0x1ae+xK_Zabovedot :: KeyVal+xK_Zabovedot = 0x1af+xK_aogonek :: KeyVal+xK_aogonek = 0x1b1+xK_ogonek :: KeyVal+xK_ogonek = 0x1b2+xK_lstroke :: KeyVal+xK_lstroke = 0x1b3+xK_lcaron :: KeyVal+xK_lcaron = 0x1b5+xK_sacute :: KeyVal+xK_sacute = 0x1b6+xK_caron :: KeyVal+xK_caron = 0x1b7+xK_scaron :: KeyVal+xK_scaron = 0x1b9+xK_scedilla :: KeyVal+xK_scedilla = 0x1ba+xK_tcaron :: KeyVal+xK_tcaron = 0x1bb+xK_zacute :: KeyVal+xK_zacute = 0x1bc+xK_doubleacute :: KeyVal+xK_doubleacute = 0x1bd+xK_zcaron :: KeyVal+xK_zcaron = 0x1be+xK_zabovedot :: KeyVal+xK_zabovedot = 0x1bf+xK_Racute :: KeyVal+xK_Racute = 0x1c0+xK_Abreve :: KeyVal+xK_Abreve = 0x1c3+xK_Lacute :: KeyVal+xK_Lacute = 0x1c5+xK_Cacute :: KeyVal+xK_Cacute = 0x1c6+xK_Ccaron :: KeyVal+xK_Ccaron = 0x1c8+xK_Eogonek :: KeyVal+xK_Eogonek = 0x1ca+xK_Ecaron :: KeyVal+xK_Ecaron = 0x1cc+xK_Dcaron :: KeyVal+xK_Dcaron = 0x1cf+xK_Dstroke :: KeyVal+xK_Dstroke = 0x1d0+xK_Nacute :: KeyVal+xK_Nacute = 0x1d1+xK_Ncaron :: KeyVal+xK_Ncaron = 0x1d2+xK_Odoubleacute :: KeyVal+xK_Odoubleacute = 0x1d5+xK_Rcaron :: KeyVal+xK_Rcaron = 0x1d8+xK_Uring :: KeyVal+xK_Uring = 0x1d9+xK_Udoubleacute :: KeyVal+xK_Udoubleacute = 0x1db+xK_Tcedilla :: KeyVal+xK_Tcedilla = 0x1de+xK_racute :: KeyVal+xK_racute = 0x1e0+xK_abreve :: KeyVal+xK_abreve = 0x1e3+xK_lacute :: KeyVal+xK_lacute = 0x1e5+xK_cacute :: KeyVal+xK_cacute = 0x1e6+xK_ccaron :: KeyVal+xK_ccaron = 0x1e8+xK_eogonek :: KeyVal+xK_eogonek = 0x1ea+xK_ecaron :: KeyVal+xK_ecaron = 0x1ec+xK_dcaron :: KeyVal+xK_dcaron = 0x1ef+xK_dstroke :: KeyVal+xK_dstroke = 0x1f0+xK_nacute :: KeyVal+xK_nacute = 0x1f1+xK_ncaron :: KeyVal+xK_ncaron = 0x1f2+xK_odoubleacute :: KeyVal+xK_odoubleacute = 0x1f5+xK_rcaron :: KeyVal+xK_rcaron = 0x1f8+xK_uring :: KeyVal+xK_uring = 0x1f9+xK_udoubleacute :: KeyVal+xK_udoubleacute = 0x1fb+xK_tcedilla :: KeyVal+xK_tcedilla = 0x1fe+xK_abovedot :: KeyVal+xK_abovedot = 0x1ff+xK_Hstroke :: KeyVal+xK_Hstroke = 0x2a1+xK_Hcircumflex :: KeyVal+xK_Hcircumflex = 0x2a6+xK_Iabovedot :: KeyVal+xK_Iabovedot = 0x2a9+xK_Gbreve :: KeyVal+xK_Gbreve = 0x2ab+xK_Jcircumflex :: KeyVal+xK_Jcircumflex = 0x2ac+xK_hstroke :: KeyVal+xK_hstroke = 0x2b1+xK_hcircumflex :: KeyVal+xK_hcircumflex = 0x2b6+xK_idotless :: KeyVal+xK_idotless = 0x2b9+xK_gbreve :: KeyVal+xK_gbreve = 0x2bb+xK_jcircumflex :: KeyVal+xK_jcircumflex = 0x2bc+xK_Cabovedot :: KeyVal+xK_Cabovedot = 0x2c5+xK_Ccircumflex :: KeyVal+xK_Ccircumflex = 0x2c6+xK_Gabovedot :: KeyVal+xK_Gabovedot = 0x2d5+xK_Gcircumflex :: KeyVal+xK_Gcircumflex = 0x2d8+xK_Ubreve :: KeyVal+xK_Ubreve = 0x2dd+xK_Scircumflex :: KeyVal+xK_Scircumflex = 0x2de+xK_cabovedot :: KeyVal+xK_cabovedot = 0x2e5+xK_ccircumflex :: KeyVal+xK_ccircumflex = 0x2e6+xK_gabovedot :: KeyVal+xK_gabovedot = 0x2f5+xK_gcircumflex :: KeyVal+xK_gcircumflex = 0x2f8+xK_ubreve :: KeyVal+xK_ubreve = 0x2fd+xK_scircumflex :: KeyVal+xK_scircumflex = 0x2fe+xK_kra :: KeyVal+xK_kra = 0x3a2+xK_kappa :: KeyVal+xK_kappa = 0x3a2+xK_Rcedilla :: KeyVal+xK_Rcedilla = 0x3a3+xK_Itilde :: KeyVal+xK_Itilde = 0x3a5+xK_Lcedilla :: KeyVal+xK_Lcedilla = 0x3a6+xK_Emacron :: KeyVal+xK_Emacron = 0x3aa+xK_Gcedilla :: KeyVal+xK_Gcedilla = 0x3ab+xK_Tslash :: KeyVal+xK_Tslash = 0x3ac+xK_rcedilla :: KeyVal+xK_rcedilla = 0x3b3+xK_itilde :: KeyVal+xK_itilde = 0x3b5+xK_lcedilla :: KeyVal+xK_lcedilla = 0x3b6+xK_emacron :: KeyVal+xK_emacron = 0x3ba+xK_gcedilla :: KeyVal+xK_gcedilla = 0x3bb+xK_tslash :: KeyVal+xK_tslash = 0x3bc+xK_ENG :: KeyVal+xK_ENG = 0x3bd+xK_eng :: KeyVal+xK_eng = 0x3bf+xK_Amacron :: KeyVal+xK_Amacron = 0x3c0+xK_Iogonek :: KeyVal+xK_Iogonek = 0x3c7+xK_Eabovedot :: KeyVal+xK_Eabovedot = 0x3cc+xK_Imacron :: KeyVal+xK_Imacron = 0x3cf+xK_Ncedilla :: KeyVal+xK_Ncedilla = 0x3d1+xK_Omacron :: KeyVal+xK_Omacron = 0x3d2+xK_Kcedilla :: KeyVal+xK_Kcedilla = 0x3d3+xK_Uogonek :: KeyVal+xK_Uogonek = 0x3d9+xK_Utilde :: KeyVal+xK_Utilde = 0x3dd+xK_Umacron :: KeyVal+xK_Umacron = 0x3de+xK_amacron :: KeyVal+xK_amacron = 0x3e0+xK_iogonek :: KeyVal+xK_iogonek = 0x3e7+xK_eabovedot :: KeyVal+xK_eabovedot = 0x3ec+xK_imacron :: KeyVal+xK_imacron = 0x3ef+xK_ncedilla :: KeyVal+xK_ncedilla = 0x3f1+xK_omacron :: KeyVal+xK_omacron = 0x3f2+xK_kcedilla :: KeyVal+xK_kcedilla = 0x3f3+xK_uogonek :: KeyVal+xK_uogonek = 0x3f9+xK_utilde :: KeyVal+xK_utilde = 0x3fd+xK_umacron :: KeyVal+xK_umacron = 0x3fe+xK_Wcircumflex :: KeyVal+xK_Wcircumflex = 0x1000174+xK_wcircumflex :: KeyVal+xK_wcircumflex = 0x1000175+xK_Ycircumflex :: KeyVal+xK_Ycircumflex = 0x1000176+xK_ycircumflex :: KeyVal+xK_ycircumflex = 0x1000177+xK_Babovedot :: KeyVal+xK_Babovedot = 0x1001e02+xK_babovedot :: KeyVal+xK_babovedot = 0x1001e03+xK_Dabovedot :: KeyVal+xK_Dabovedot = 0x1001e0a+xK_dabovedot :: KeyVal+xK_dabovedot = 0x1001e0b+xK_Fabovedot :: KeyVal+xK_Fabovedot = 0x1001e1e+xK_fabovedot :: KeyVal+xK_fabovedot = 0x1001e1f+xK_Mabovedot :: KeyVal+xK_Mabovedot = 0x1001e40+xK_mabovedot :: KeyVal+xK_mabovedot = 0x1001e41+xK_Pabovedot :: KeyVal+xK_Pabovedot = 0x1001e56+xK_pabovedot :: KeyVal+xK_pabovedot = 0x1001e57+xK_Sabovedot :: KeyVal+xK_Sabovedot = 0x1001e60+xK_sabovedot :: KeyVal+xK_sabovedot = 0x1001e61+xK_Tabovedot :: KeyVal+xK_Tabovedot = 0x1001e6a+xK_tabovedot :: KeyVal+xK_tabovedot = 0x1001e6b+xK_Wgrave :: KeyVal+xK_Wgrave = 0x1001e80+xK_wgrave :: KeyVal+xK_wgrave = 0x1001e81+xK_Wacute :: KeyVal+xK_Wacute = 0x1001e82+xK_wacute :: KeyVal+xK_wacute = 0x1001e83+xK_Wdiaeresis :: KeyVal+xK_Wdiaeresis = 0x1001e84+xK_wdiaeresis :: KeyVal+xK_wdiaeresis = 0x1001e85+xK_Ygrave :: KeyVal+xK_Ygrave = 0x1001ef2+xK_ygrave :: KeyVal+xK_ygrave = 0x1001ef3+xK_OE :: KeyVal+xK_OE = 0x13bc+xK_oe :: KeyVal+xK_oe = 0x13bd+xK_Ydiaeresis :: KeyVal+xK_Ydiaeresis = 0x13be+xK_overline :: KeyVal+xK_overline = 0x47e+xK_kana_fullstop :: KeyVal+xK_kana_fullstop = 0x4a1+xK_kana_openingbracket :: KeyVal+xK_kana_openingbracket = 0x4a2+xK_kana_closingbracket :: KeyVal+xK_kana_closingbracket = 0x4a3+xK_kana_comma :: KeyVal+xK_kana_comma = 0x4a4+xK_kana_conjunctive :: KeyVal+xK_kana_conjunctive = 0x4a5+xK_kana_middledot :: KeyVal+xK_kana_middledot = 0x4a5+xK_kana_WO :: KeyVal+xK_kana_WO = 0x4a6+xK_kana_a :: KeyVal+xK_kana_a = 0x4a7+xK_kana_i :: KeyVal+xK_kana_i = 0x4a8+xK_kana_u :: KeyVal+xK_kana_u = 0x4a9+xK_kana_e :: KeyVal+xK_kana_e = 0x4aa+xK_kana_o :: KeyVal+xK_kana_o = 0x4ab+xK_kana_ya :: KeyVal+xK_kana_ya = 0x4ac+xK_kana_yu :: KeyVal+xK_kana_yu = 0x4ad+xK_kana_yo :: KeyVal+xK_kana_yo = 0x4ae+xK_kana_tsu :: KeyVal+xK_kana_tsu = 0x4af+xK_kana_tu :: KeyVal+xK_kana_tu = 0x4af+xK_prolongedsound :: KeyVal+xK_prolongedsound = 0x4b0+xK_kana_A :: KeyVal+xK_kana_A = 0x4b1+xK_kana_I :: KeyVal+xK_kana_I = 0x4b2+xK_kana_U :: KeyVal+xK_kana_U = 0x4b3+xK_kana_E :: KeyVal+xK_kana_E = 0x4b4+xK_kana_O :: KeyVal+xK_kana_O = 0x4b5+xK_kana_KA :: KeyVal+xK_kana_KA = 0x4b6+xK_kana_KI :: KeyVal+xK_kana_KI = 0x4b7+xK_kana_KU :: KeyVal+xK_kana_KU = 0x4b8+xK_kana_KE :: KeyVal+xK_kana_KE = 0x4b9+xK_kana_KO :: KeyVal+xK_kana_KO = 0x4ba+xK_kana_SA :: KeyVal+xK_kana_SA = 0x4bb+xK_kana_SHI :: KeyVal+xK_kana_SHI = 0x4bc+xK_kana_SU :: KeyVal+xK_kana_SU = 0x4bd+xK_kana_SE :: KeyVal+xK_kana_SE = 0x4be+xK_kana_SO :: KeyVal+xK_kana_SO = 0x4bf+xK_kana_TA :: KeyVal+xK_kana_TA = 0x4c0+xK_kana_CHI :: KeyVal+xK_kana_CHI = 0x4c1+xK_kana_TI :: KeyVal+xK_kana_TI = 0x4c1+xK_kana_TSU :: KeyVal+xK_kana_TSU = 0x4c2+xK_kana_TU :: KeyVal+xK_kana_TU = 0x4c2+xK_kana_TE :: KeyVal+xK_kana_TE = 0x4c3+xK_kana_TO :: KeyVal+xK_kana_TO = 0x4c4+xK_kana_NA :: KeyVal+xK_kana_NA = 0x4c5+xK_kana_NI :: KeyVal+xK_kana_NI = 0x4c6+xK_kana_NU :: KeyVal+xK_kana_NU = 0x4c7+xK_kana_NE :: KeyVal+xK_kana_NE = 0x4c8+xK_kana_NO :: KeyVal+xK_kana_NO = 0x4c9+xK_kana_HA :: KeyVal+xK_kana_HA = 0x4ca+xK_kana_HI :: KeyVal+xK_kana_HI = 0x4cb+xK_kana_FU :: KeyVal+xK_kana_FU = 0x4cc+xK_kana_HU :: KeyVal+xK_kana_HU = 0x4cc+xK_kana_HE :: KeyVal+xK_kana_HE = 0x4cd+xK_kana_HO :: KeyVal+xK_kana_HO = 0x4ce+xK_kana_MA :: KeyVal+xK_kana_MA = 0x4cf+xK_kana_MI :: KeyVal+xK_kana_MI = 0x4d0+xK_kana_MU :: KeyVal+xK_kana_MU = 0x4d1+xK_kana_ME :: KeyVal+xK_kana_ME = 0x4d2+xK_kana_MO :: KeyVal+xK_kana_MO = 0x4d3+xK_kana_YA :: KeyVal+xK_kana_YA = 0x4d4+xK_kana_YU :: KeyVal+xK_kana_YU = 0x4d5+xK_kana_YO :: KeyVal+xK_kana_YO = 0x4d6+xK_kana_RA :: KeyVal+xK_kana_RA = 0x4d7+xK_kana_RI :: KeyVal+xK_kana_RI = 0x4d8+xK_kana_RU :: KeyVal+xK_kana_RU = 0x4d9+xK_kana_RE :: KeyVal+xK_kana_RE = 0x4da+xK_kana_RO :: KeyVal+xK_kana_RO = 0x4db+xK_kana_WA :: KeyVal+xK_kana_WA = 0x4dc+xK_kana_N :: KeyVal+xK_kana_N = 0x4dd+xK_voicedsound :: KeyVal+xK_voicedsound = 0x4de+xK_semivoicedsound :: KeyVal+xK_semivoicedsound = 0x4df+xK_kana_switch :: KeyVal+xK_kana_switch = 0xff7e+xK_Farsi_0 :: KeyVal+xK_Farsi_0 = 0x10006f0+xK_Farsi_1 :: KeyVal+xK_Farsi_1 = 0x10006f1+xK_Farsi_2 :: KeyVal+xK_Farsi_2 = 0x10006f2+xK_Farsi_3 :: KeyVal+xK_Farsi_3 = 0x10006f3+xK_Farsi_4 :: KeyVal+xK_Farsi_4 = 0x10006f4+xK_Farsi_5 :: KeyVal+xK_Farsi_5 = 0x10006f5+xK_Farsi_6 :: KeyVal+xK_Farsi_6 = 0x10006f6+xK_Farsi_7 :: KeyVal+xK_Farsi_7 = 0x10006f7+xK_Farsi_8 :: KeyVal+xK_Farsi_8 = 0x10006f8+xK_Farsi_9 :: KeyVal+xK_Farsi_9 = 0x10006f9+xK_Arabic_percent :: KeyVal+xK_Arabic_percent = 0x100066a+xK_Arabic_superscript_alef :: KeyVal+xK_Arabic_superscript_alef = 0x1000670+xK_Arabic_tteh :: KeyVal+xK_Arabic_tteh = 0x1000679+xK_Arabic_peh :: KeyVal+xK_Arabic_peh = 0x100067e+xK_Arabic_tcheh :: KeyVal+xK_Arabic_tcheh = 0x1000686+xK_Arabic_ddal :: KeyVal+xK_Arabic_ddal = 0x1000688+xK_Arabic_rreh :: KeyVal+xK_Arabic_rreh = 0x1000691+xK_Arabic_comma :: KeyVal+xK_Arabic_comma = 0x5ac+xK_Arabic_fullstop :: KeyVal+xK_Arabic_fullstop = 0x10006d4+xK_Arabic_0 :: KeyVal+xK_Arabic_0 = 0x1000660+xK_Arabic_1 :: KeyVal+xK_Arabic_1 = 0x1000661+xK_Arabic_2 :: KeyVal+xK_Arabic_2 = 0x1000662+xK_Arabic_3 :: KeyVal+xK_Arabic_3 = 0x1000663+xK_Arabic_4 :: KeyVal+xK_Arabic_4 = 0x1000664+xK_Arabic_5 :: KeyVal+xK_Arabic_5 = 0x1000665+xK_Arabic_6 :: KeyVal+xK_Arabic_6 = 0x1000666+xK_Arabic_7 :: KeyVal+xK_Arabic_7 = 0x1000667+xK_Arabic_8 :: KeyVal+xK_Arabic_8 = 0x1000668+xK_Arabic_9 :: KeyVal+xK_Arabic_9 = 0x1000669+xK_Arabic_semicolon :: KeyVal+xK_Arabic_semicolon = 0x5bb+xK_Arabic_question_mark :: KeyVal+xK_Arabic_question_mark = 0x5bf+xK_Arabic_hamza :: KeyVal+xK_Arabic_hamza = 0x5c1+xK_Arabic_maddaonalef :: KeyVal+xK_Arabic_maddaonalef = 0x5c2+xK_Arabic_hamzaonalef :: KeyVal+xK_Arabic_hamzaonalef = 0x5c3+xK_Arabic_hamzaonwaw :: KeyVal+xK_Arabic_hamzaonwaw = 0x5c4+xK_Arabic_hamzaunderalef :: KeyVal+xK_Arabic_hamzaunderalef = 0x5c5+xK_Arabic_hamzaonyeh :: KeyVal+xK_Arabic_hamzaonyeh = 0x5c6+xK_Arabic_alef :: KeyVal+xK_Arabic_alef = 0x5c7+xK_Arabic_beh :: KeyVal+xK_Arabic_beh = 0x5c8+xK_Arabic_tehmarbuta :: KeyVal+xK_Arabic_tehmarbuta = 0x5c9+xK_Arabic_teh :: KeyVal+xK_Arabic_teh = 0x5ca+xK_Arabic_theh :: KeyVal+xK_Arabic_theh = 0x5cb+xK_Arabic_jeem :: KeyVal+xK_Arabic_jeem = 0x5cc+xK_Arabic_hah :: KeyVal+xK_Arabic_hah = 0x5cd+xK_Arabic_khah :: KeyVal+xK_Arabic_khah = 0x5ce+xK_Arabic_dal :: KeyVal+xK_Arabic_dal = 0x5cf+xK_Arabic_thal :: KeyVal+xK_Arabic_thal = 0x5d0+xK_Arabic_ra :: KeyVal+xK_Arabic_ra = 0x5d1+xK_Arabic_zain :: KeyVal+xK_Arabic_zain = 0x5d2+xK_Arabic_seen :: KeyVal+xK_Arabic_seen = 0x5d3+xK_Arabic_sheen :: KeyVal+xK_Arabic_sheen = 0x5d4+xK_Arabic_sad :: KeyVal+xK_Arabic_sad = 0x5d5+xK_Arabic_dad :: KeyVal+xK_Arabic_dad = 0x5d6+xK_Arabic_tah :: KeyVal+xK_Arabic_tah = 0x5d7+xK_Arabic_zah :: KeyVal+xK_Arabic_zah = 0x5d8+xK_Arabic_ain :: KeyVal+xK_Arabic_ain = 0x5d9+xK_Arabic_ghain :: KeyVal+xK_Arabic_ghain = 0x5da+xK_Arabic_tatweel :: KeyVal+xK_Arabic_tatweel = 0x5e0+xK_Arabic_feh :: KeyVal+xK_Arabic_feh = 0x5e1+xK_Arabic_qaf :: KeyVal+xK_Arabic_qaf = 0x5e2+xK_Arabic_kaf :: KeyVal+xK_Arabic_kaf = 0x5e3+xK_Arabic_lam :: KeyVal+xK_Arabic_lam = 0x5e4+xK_Arabic_meem :: KeyVal+xK_Arabic_meem = 0x5e5+xK_Arabic_noon :: KeyVal+xK_Arabic_noon = 0x5e6+xK_Arabic_ha :: KeyVal+xK_Arabic_ha = 0x5e7+xK_Arabic_heh :: KeyVal+xK_Arabic_heh = 0x5e7+xK_Arabic_waw :: KeyVal+xK_Arabic_waw = 0x5e8+xK_Arabic_alefmaksura :: KeyVal+xK_Arabic_alefmaksura = 0x5e9+xK_Arabic_yeh :: KeyVal+xK_Arabic_yeh = 0x5ea+xK_Arabic_fathatan :: KeyVal+xK_Arabic_fathatan = 0x5eb+xK_Arabic_dammatan :: KeyVal+xK_Arabic_dammatan = 0x5ec+xK_Arabic_kasratan :: KeyVal+xK_Arabic_kasratan = 0x5ed+xK_Arabic_fatha :: KeyVal+xK_Arabic_fatha = 0x5ee+xK_Arabic_damma :: KeyVal+xK_Arabic_damma = 0x5ef+xK_Arabic_kasra :: KeyVal+xK_Arabic_kasra = 0x5f0+xK_Arabic_shadda :: KeyVal+xK_Arabic_shadda = 0x5f1+xK_Arabic_sukun :: KeyVal+xK_Arabic_sukun = 0x5f2+xK_Arabic_madda_above :: KeyVal+xK_Arabic_madda_above = 0x1000653+xK_Arabic_hamza_above :: KeyVal+xK_Arabic_hamza_above = 0x1000654+xK_Arabic_hamza_below :: KeyVal+xK_Arabic_hamza_below = 0x1000655+xK_Arabic_jeh :: KeyVal+xK_Arabic_jeh = 0x1000698+xK_Arabic_veh :: KeyVal+xK_Arabic_veh = 0x10006a4+xK_Arabic_keheh :: KeyVal+xK_Arabic_keheh = 0x10006a9+xK_Arabic_gaf :: KeyVal+xK_Arabic_gaf = 0x10006af+xK_Arabic_noon_ghunna :: KeyVal+xK_Arabic_noon_ghunna = 0x10006ba+xK_Arabic_heh_doachashmee :: KeyVal+xK_Arabic_heh_doachashmee = 0x10006be+xK_Farsi_yeh :: KeyVal+xK_Farsi_yeh = 0x10006cc+xK_Arabic_farsi_yeh :: KeyVal+xK_Arabic_farsi_yeh = 0x10006cc+xK_Arabic_yeh_baree :: KeyVal+xK_Arabic_yeh_baree = 0x10006d2+xK_Arabic_heh_goal :: KeyVal+xK_Arabic_heh_goal = 0x10006c1+xK_Arabic_switch :: KeyVal+xK_Arabic_switch = 0xff7e+xK_Cyrillic_GHE_bar :: KeyVal+xK_Cyrillic_GHE_bar = 0x1000492+xK_Cyrillic_ghe_bar :: KeyVal+xK_Cyrillic_ghe_bar = 0x1000493+xK_Cyrillic_ZHE_descender :: KeyVal+xK_Cyrillic_ZHE_descender = 0x1000496+xK_Cyrillic_zhe_descender :: KeyVal+xK_Cyrillic_zhe_descender = 0x1000497+xK_Cyrillic_KA_descender :: KeyVal+xK_Cyrillic_KA_descender = 0x100049a+xK_Cyrillic_ka_descender :: KeyVal+xK_Cyrillic_ka_descender = 0x100049b+xK_Cyrillic_KA_vertstroke :: KeyVal+xK_Cyrillic_KA_vertstroke = 0x100049c+xK_Cyrillic_ka_vertstroke :: KeyVal+xK_Cyrillic_ka_vertstroke = 0x100049d+xK_Cyrillic_EN_descender :: KeyVal+xK_Cyrillic_EN_descender = 0x10004a2+xK_Cyrillic_en_descender :: KeyVal+xK_Cyrillic_en_descender = 0x10004a3+xK_Cyrillic_U_straight :: KeyVal+xK_Cyrillic_U_straight = 0x10004ae+xK_Cyrillic_u_straight :: KeyVal+xK_Cyrillic_u_straight = 0x10004af+xK_Cyrillic_U_straight_bar :: KeyVal+xK_Cyrillic_U_straight_bar = 0x10004b0+xK_Cyrillic_u_straight_bar :: KeyVal+xK_Cyrillic_u_straight_bar = 0x10004b1+xK_Cyrillic_HA_descender :: KeyVal+xK_Cyrillic_HA_descender = 0x10004b2+xK_Cyrillic_ha_descender :: KeyVal+xK_Cyrillic_ha_descender = 0x10004b3+xK_Cyrillic_CHE_descender :: KeyVal+xK_Cyrillic_CHE_descender = 0x10004b6+xK_Cyrillic_che_descender :: KeyVal+xK_Cyrillic_che_descender = 0x10004b7+xK_Cyrillic_CHE_vertstroke :: KeyVal+xK_Cyrillic_CHE_vertstroke = 0x10004b8+xK_Cyrillic_che_vertstroke :: KeyVal+xK_Cyrillic_che_vertstroke = 0x10004b9+xK_Cyrillic_SHHA :: KeyVal+xK_Cyrillic_SHHA = 0x10004ba+xK_Cyrillic_shha :: KeyVal+xK_Cyrillic_shha = 0x10004bb+xK_Cyrillic_SCHWA :: KeyVal+xK_Cyrillic_SCHWA = 0x10004d8+xK_Cyrillic_schwa :: KeyVal+xK_Cyrillic_schwa = 0x10004d9+xK_Cyrillic_I_macron :: KeyVal+xK_Cyrillic_I_macron = 0x10004e2+xK_Cyrillic_i_macron :: KeyVal+xK_Cyrillic_i_macron = 0x10004e3+xK_Cyrillic_O_bar :: KeyVal+xK_Cyrillic_O_bar = 0x10004e8+xK_Cyrillic_o_bar :: KeyVal+xK_Cyrillic_o_bar = 0x10004e9+xK_Cyrillic_U_macron :: KeyVal+xK_Cyrillic_U_macron = 0x10004ee+xK_Cyrillic_u_macron :: KeyVal+xK_Cyrillic_u_macron = 0x10004ef+xK_Serbian_dje :: KeyVal+xK_Serbian_dje = 0x6a1+xK_Macedonia_gje :: KeyVal+xK_Macedonia_gje = 0x6a2+xK_Cyrillic_io :: KeyVal+xK_Cyrillic_io = 0x6a3+xK_Ukrainian_ie :: KeyVal+xK_Ukrainian_ie = 0x6a4+xK_Ukranian_je :: KeyVal+xK_Ukranian_je = 0x6a4+xK_Macedonia_dse :: KeyVal+xK_Macedonia_dse = 0x6a5+xK_Ukrainian_i :: KeyVal+xK_Ukrainian_i = 0x6a6+xK_Ukranian_i :: KeyVal+xK_Ukranian_i = 0x6a6+xK_Ukrainian_yi :: KeyVal+xK_Ukrainian_yi = 0x6a7+xK_Ukranian_yi :: KeyVal+xK_Ukranian_yi = 0x6a7+xK_Cyrillic_je :: KeyVal+xK_Cyrillic_je = 0x6a8+xK_Serbian_je :: KeyVal+xK_Serbian_je = 0x6a8+xK_Cyrillic_lje :: KeyVal+xK_Cyrillic_lje = 0x6a9+xK_Serbian_lje :: KeyVal+xK_Serbian_lje = 0x6a9+xK_Cyrillic_nje :: KeyVal+xK_Cyrillic_nje = 0x6aa+xK_Serbian_nje :: KeyVal+xK_Serbian_nje = 0x6aa+xK_Serbian_tshe :: KeyVal+xK_Serbian_tshe = 0x6ab+xK_Macedonia_kje :: KeyVal+xK_Macedonia_kje = 0x6ac+xK_Ukrainian_ghe_with_upturn :: KeyVal+xK_Ukrainian_ghe_with_upturn = 0x6ad+xK_Byelorussian_shortu :: KeyVal+xK_Byelorussian_shortu = 0x6ae+xK_Cyrillic_dzhe :: KeyVal+xK_Cyrillic_dzhe = 0x6af+xK_Serbian_dze :: KeyVal+xK_Serbian_dze = 0x6af+xK_numerosign :: KeyVal+xK_numerosign = 0x6b0+xK_Serbian_DJE :: KeyVal+xK_Serbian_DJE = 0x6b1+xK_Macedonia_GJE :: KeyVal+xK_Macedonia_GJE = 0x6b2+xK_Cyrillic_IO :: KeyVal+xK_Cyrillic_IO = 0x6b3+xK_Ukrainian_IE :: KeyVal+xK_Ukrainian_IE = 0x6b4+xK_Ukranian_JE :: KeyVal+xK_Ukranian_JE = 0x6b4+xK_Macedonia_DSE :: KeyVal+xK_Macedonia_DSE = 0x6b5+xK_Ukrainian_I :: KeyVal+xK_Ukrainian_I = 0x6b6+xK_Ukranian_I :: KeyVal+xK_Ukranian_I = 0x6b6+xK_Ukrainian_YI :: KeyVal+xK_Ukrainian_YI = 0x6b7+xK_Ukranian_YI :: KeyVal+xK_Ukranian_YI = 0x6b7+xK_Cyrillic_JE :: KeyVal+xK_Cyrillic_JE = 0x6b8+xK_Serbian_JE :: KeyVal+xK_Serbian_JE = 0x6b8+xK_Cyrillic_LJE :: KeyVal+xK_Cyrillic_LJE = 0x6b9+xK_Serbian_LJE :: KeyVal+xK_Serbian_LJE = 0x6b9+xK_Cyrillic_NJE :: KeyVal+xK_Cyrillic_NJE = 0x6ba+xK_Serbian_NJE :: KeyVal+xK_Serbian_NJE = 0x6ba+xK_Serbian_TSHE :: KeyVal+xK_Serbian_TSHE = 0x6bb+xK_Macedonia_KJE :: KeyVal+xK_Macedonia_KJE = 0x6bc+xK_Ukrainian_GHE_WITH_UPTURN :: KeyVal+xK_Ukrainian_GHE_WITH_UPTURN = 0x6bd+xK_Byelorussian_SHORTU :: KeyVal+xK_Byelorussian_SHORTU = 0x6be+xK_Cyrillic_DZHE :: KeyVal+xK_Cyrillic_DZHE = 0x6bf+xK_Serbian_DZE :: KeyVal+xK_Serbian_DZE = 0x6bf+xK_Cyrillic_yu :: KeyVal+xK_Cyrillic_yu = 0x6c0+xK_Cyrillic_a :: KeyVal+xK_Cyrillic_a = 0x6c1+xK_Cyrillic_be :: KeyVal+xK_Cyrillic_be = 0x6c2+xK_Cyrillic_tse :: KeyVal+xK_Cyrillic_tse = 0x6c3+xK_Cyrillic_de :: KeyVal+xK_Cyrillic_de = 0x6c4+xK_Cyrillic_ie :: KeyVal+xK_Cyrillic_ie = 0x6c5+xK_Cyrillic_ef :: KeyVal+xK_Cyrillic_ef = 0x6c6+xK_Cyrillic_ghe :: KeyVal+xK_Cyrillic_ghe = 0x6c7+xK_Cyrillic_ha :: KeyVal+xK_Cyrillic_ha = 0x6c8+xK_Cyrillic_i :: KeyVal+xK_Cyrillic_i = 0x6c9+xK_Cyrillic_shorti :: KeyVal+xK_Cyrillic_shorti = 0x6ca+xK_Cyrillic_ka :: KeyVal+xK_Cyrillic_ka = 0x6cb+xK_Cyrillic_el :: KeyVal+xK_Cyrillic_el = 0x6cc+xK_Cyrillic_em :: KeyVal+xK_Cyrillic_em = 0x6cd+xK_Cyrillic_en :: KeyVal+xK_Cyrillic_en = 0x6ce+xK_Cyrillic_o :: KeyVal+xK_Cyrillic_o = 0x6cf+xK_Cyrillic_pe :: KeyVal+xK_Cyrillic_pe = 0x6d0+xK_Cyrillic_ya :: KeyVal+xK_Cyrillic_ya = 0x6d1+xK_Cyrillic_er :: KeyVal+xK_Cyrillic_er = 0x6d2+xK_Cyrillic_es :: KeyVal+xK_Cyrillic_es = 0x6d3+xK_Cyrillic_te :: KeyVal+xK_Cyrillic_te = 0x6d4+xK_Cyrillic_u :: KeyVal+xK_Cyrillic_u = 0x6d5+xK_Cyrillic_zhe :: KeyVal+xK_Cyrillic_zhe = 0x6d6+xK_Cyrillic_ve :: KeyVal+xK_Cyrillic_ve = 0x6d7+xK_Cyrillic_softsign :: KeyVal+xK_Cyrillic_softsign = 0x6d8+xK_Cyrillic_yeru :: KeyVal+xK_Cyrillic_yeru = 0x6d9+xK_Cyrillic_ze :: KeyVal+xK_Cyrillic_ze = 0x6da+xK_Cyrillic_sha :: KeyVal+xK_Cyrillic_sha = 0x6db+xK_Cyrillic_e :: KeyVal+xK_Cyrillic_e = 0x6dc+xK_Cyrillic_shcha :: KeyVal+xK_Cyrillic_shcha = 0x6dd+xK_Cyrillic_che :: KeyVal+xK_Cyrillic_che = 0x6de+xK_Cyrillic_hardsign :: KeyVal+xK_Cyrillic_hardsign = 0x6df+xK_Cyrillic_YU :: KeyVal+xK_Cyrillic_YU = 0x6e0+xK_Cyrillic_A :: KeyVal+xK_Cyrillic_A = 0x6e1+xK_Cyrillic_BE :: KeyVal+xK_Cyrillic_BE = 0x6e2+xK_Cyrillic_TSE :: KeyVal+xK_Cyrillic_TSE = 0x6e3+xK_Cyrillic_DE :: KeyVal+xK_Cyrillic_DE = 0x6e4+xK_Cyrillic_IE :: KeyVal+xK_Cyrillic_IE = 0x6e5+xK_Cyrillic_EF :: KeyVal+xK_Cyrillic_EF = 0x6e6+xK_Cyrillic_GHE :: KeyVal+xK_Cyrillic_GHE = 0x6e7+xK_Cyrillic_HA :: KeyVal+xK_Cyrillic_HA = 0x6e8+xK_Cyrillic_I :: KeyVal+xK_Cyrillic_I = 0x6e9+xK_Cyrillic_SHORTI :: KeyVal+xK_Cyrillic_SHORTI = 0x6ea+xK_Cyrillic_KA :: KeyVal+xK_Cyrillic_KA = 0x6eb+xK_Cyrillic_EL :: KeyVal+xK_Cyrillic_EL = 0x6ec+xK_Cyrillic_EM :: KeyVal+xK_Cyrillic_EM = 0x6ed+xK_Cyrillic_EN :: KeyVal+xK_Cyrillic_EN = 0x6ee+xK_Cyrillic_O :: KeyVal+xK_Cyrillic_O = 0x6ef+xK_Cyrillic_PE :: KeyVal+xK_Cyrillic_PE = 0x6f0+xK_Cyrillic_YA :: KeyVal+xK_Cyrillic_YA = 0x6f1+xK_Cyrillic_ER :: KeyVal+xK_Cyrillic_ER = 0x6f2+xK_Cyrillic_ES :: KeyVal+xK_Cyrillic_ES = 0x6f3+xK_Cyrillic_TE :: KeyVal+xK_Cyrillic_TE = 0x6f4+xK_Cyrillic_U :: KeyVal+xK_Cyrillic_U = 0x6f5+xK_Cyrillic_ZHE :: KeyVal+xK_Cyrillic_ZHE = 0x6f6+xK_Cyrillic_VE :: KeyVal+xK_Cyrillic_VE = 0x6f7+xK_Cyrillic_SOFTSIGN :: KeyVal+xK_Cyrillic_SOFTSIGN = 0x6f8+xK_Cyrillic_YERU :: KeyVal+xK_Cyrillic_YERU = 0x6f9+xK_Cyrillic_ZE :: KeyVal+xK_Cyrillic_ZE = 0x6fa+xK_Cyrillic_SHA :: KeyVal+xK_Cyrillic_SHA = 0x6fb+xK_Cyrillic_E :: KeyVal+xK_Cyrillic_E = 0x6fc+xK_Cyrillic_SHCHA :: KeyVal+xK_Cyrillic_SHCHA = 0x6fd+xK_Cyrillic_CHE :: KeyVal+xK_Cyrillic_CHE = 0x6fe+xK_Cyrillic_HARDSIGN :: KeyVal+xK_Cyrillic_HARDSIGN = 0x6ff+xK_Greek_ALPHAaccent :: KeyVal+xK_Greek_ALPHAaccent = 0x7a1+xK_Greek_EPSILONaccent :: KeyVal+xK_Greek_EPSILONaccent = 0x7a2+xK_Greek_ETAaccent :: KeyVal+xK_Greek_ETAaccent = 0x7a3+xK_Greek_IOTAaccent :: KeyVal+xK_Greek_IOTAaccent = 0x7a4+xK_Greek_IOTAdieresis :: KeyVal+xK_Greek_IOTAdieresis = 0x7a5+xK_Greek_IOTAdiaeresis :: KeyVal+xK_Greek_IOTAdiaeresis = 0x7a5+xK_Greek_OMICRONaccent :: KeyVal+xK_Greek_OMICRONaccent = 0x7a7+xK_Greek_UPSILONaccent :: KeyVal+xK_Greek_UPSILONaccent = 0x7a8+xK_Greek_UPSILONdieresis :: KeyVal+xK_Greek_UPSILONdieresis = 0x7a9+xK_Greek_OMEGAaccent :: KeyVal+xK_Greek_OMEGAaccent = 0x7ab+xK_Greek_accentdieresis :: KeyVal+xK_Greek_accentdieresis = 0x7ae+xK_Greek_horizbar :: KeyVal+xK_Greek_horizbar = 0x7af+xK_Greek_alphaaccent :: KeyVal+xK_Greek_alphaaccent = 0x7b1+xK_Greek_epsilonaccent :: KeyVal+xK_Greek_epsilonaccent = 0x7b2+xK_Greek_etaaccent :: KeyVal+xK_Greek_etaaccent = 0x7b3+xK_Greek_iotaaccent :: KeyVal+xK_Greek_iotaaccent = 0x7b4+xK_Greek_iotadieresis :: KeyVal+xK_Greek_iotadieresis = 0x7b5+xK_Greek_iotaaccentdieresis :: KeyVal+xK_Greek_iotaaccentdieresis = 0x7b6+xK_Greek_omicronaccent :: KeyVal+xK_Greek_omicronaccent = 0x7b7+xK_Greek_upsilonaccent :: KeyVal+xK_Greek_upsilonaccent = 0x7b8+xK_Greek_upsilondieresis :: KeyVal+xK_Greek_upsilondieresis = 0x7b9+xK_Greek_upsilonaccentdieresis :: KeyVal+xK_Greek_upsilonaccentdieresis = 0x7ba+xK_Greek_omegaaccent :: KeyVal+xK_Greek_omegaaccent = 0x7bb+xK_Greek_ALPHA :: KeyVal+xK_Greek_ALPHA = 0x7c1+xK_Greek_BETA :: KeyVal+xK_Greek_BETA = 0x7c2+xK_Greek_GAMMA :: KeyVal+xK_Greek_GAMMA = 0x7c3+xK_Greek_DELTA :: KeyVal+xK_Greek_DELTA = 0x7c4+xK_Greek_EPSILON :: KeyVal+xK_Greek_EPSILON = 0x7c5+xK_Greek_ZETA :: KeyVal+xK_Greek_ZETA = 0x7c6+xK_Greek_ETA :: KeyVal+xK_Greek_ETA = 0x7c7+xK_Greek_THETA :: KeyVal+xK_Greek_THETA = 0x7c8+xK_Greek_IOTA :: KeyVal+xK_Greek_IOTA = 0x7c9+xK_Greek_KAPPA :: KeyVal+xK_Greek_KAPPA = 0x7ca+xK_Greek_LAMDA :: KeyVal+xK_Greek_LAMDA = 0x7cb+xK_Greek_LAMBDA :: KeyVal+xK_Greek_LAMBDA = 0x7cb+xK_Greek_MU :: KeyVal+xK_Greek_MU = 0x7cc+xK_Greek_NU :: KeyVal+xK_Greek_NU = 0x7cd+xK_Greek_XI :: KeyVal+xK_Greek_XI = 0x7ce+xK_Greek_OMICRON :: KeyVal+xK_Greek_OMICRON = 0x7cf+xK_Greek_PI :: KeyVal+xK_Greek_PI = 0x7d0+xK_Greek_RHO :: KeyVal+xK_Greek_RHO = 0x7d1+xK_Greek_SIGMA :: KeyVal+xK_Greek_SIGMA = 0x7d2+xK_Greek_TAU :: KeyVal+xK_Greek_TAU = 0x7d4+xK_Greek_UPSILON :: KeyVal+xK_Greek_UPSILON = 0x7d5+xK_Greek_PHI :: KeyVal+xK_Greek_PHI = 0x7d6+xK_Greek_CHI :: KeyVal+xK_Greek_CHI = 0x7d7+xK_Greek_PSI :: KeyVal+xK_Greek_PSI = 0x7d8+xK_Greek_OMEGA :: KeyVal+xK_Greek_OMEGA = 0x7d9+xK_Greek_alpha :: KeyVal+xK_Greek_alpha = 0x7e1+xK_Greek_beta :: KeyVal+xK_Greek_beta = 0x7e2+xK_Greek_gamma :: KeyVal+xK_Greek_gamma = 0x7e3+xK_Greek_delta :: KeyVal+xK_Greek_delta = 0x7e4+xK_Greek_epsilon :: KeyVal+xK_Greek_epsilon = 0x7e5+xK_Greek_zeta :: KeyVal+xK_Greek_zeta = 0x7e6+xK_Greek_eta :: KeyVal+xK_Greek_eta = 0x7e7+xK_Greek_theta :: KeyVal+xK_Greek_theta = 0x7e8+xK_Greek_iota :: KeyVal+xK_Greek_iota = 0x7e9+xK_Greek_kappa :: KeyVal+xK_Greek_kappa = 0x7ea+xK_Greek_lamda :: KeyVal+xK_Greek_lamda = 0x7eb+xK_Greek_lambda :: KeyVal+xK_Greek_lambda = 0x7eb+xK_Greek_mu :: KeyVal+xK_Greek_mu = 0x7ec+xK_Greek_nu :: KeyVal+xK_Greek_nu = 0x7ed+xK_Greek_xi :: KeyVal+xK_Greek_xi = 0x7ee+xK_Greek_omicron :: KeyVal+xK_Greek_omicron = 0x7ef+xK_Greek_pi :: KeyVal+xK_Greek_pi = 0x7f0+xK_Greek_rho :: KeyVal+xK_Greek_rho = 0x7f1+xK_Greek_sigma :: KeyVal+xK_Greek_sigma = 0x7f2+xK_Greek_finalsmallsigma :: KeyVal+xK_Greek_finalsmallsigma = 0x7f3+xK_Greek_tau :: KeyVal+xK_Greek_tau = 0x7f4+xK_Greek_upsilon :: KeyVal+xK_Greek_upsilon = 0x7f5+xK_Greek_phi :: KeyVal+xK_Greek_phi = 0x7f6+xK_Greek_chi :: KeyVal+xK_Greek_chi = 0x7f7+xK_Greek_psi :: KeyVal+xK_Greek_psi = 0x7f8+xK_Greek_omega :: KeyVal+xK_Greek_omega = 0x7f9+xK_Greek_switch :: KeyVal+xK_Greek_switch = 0xff7e+xK_leftradical :: KeyVal+xK_leftradical = 0x8a1+xK_topleftradical :: KeyVal+xK_topleftradical = 0x8a2+xK_horizconnector :: KeyVal+xK_horizconnector = 0x8a3+xK_topintegral :: KeyVal+xK_topintegral = 0x8a4+xK_botintegral :: KeyVal+xK_botintegral = 0x8a5+xK_vertconnector :: KeyVal+xK_vertconnector = 0x8a6+xK_topleftsqbracket :: KeyVal+xK_topleftsqbracket = 0x8a7+xK_botleftsqbracket :: KeyVal+xK_botleftsqbracket = 0x8a8+xK_toprightsqbracket :: KeyVal+xK_toprightsqbracket = 0x8a9+xK_botrightsqbracket :: KeyVal+xK_botrightsqbracket = 0x8aa+xK_topleftparens :: KeyVal+xK_topleftparens = 0x8ab+xK_botleftparens :: KeyVal+xK_botleftparens = 0x8ac+xK_toprightparens :: KeyVal+xK_toprightparens = 0x8ad+xK_botrightparens :: KeyVal+xK_botrightparens = 0x8ae+xK_leftmiddlecurlybrace :: KeyVal+xK_leftmiddlecurlybrace = 0x8af+xK_rightmiddlecurlybrace :: KeyVal+xK_rightmiddlecurlybrace = 0x8b0+xK_topleftsummation :: KeyVal+xK_topleftsummation = 0x8b1+xK_botleftsummation :: KeyVal+xK_botleftsummation = 0x8b2+xK_topvertsummationconnector :: KeyVal+xK_topvertsummationconnector = 0x8b3+xK_botvertsummationconnector :: KeyVal+xK_botvertsummationconnector = 0x8b4+xK_toprightsummation :: KeyVal+xK_toprightsummation = 0x8b5+xK_botrightsummation :: KeyVal+xK_botrightsummation = 0x8b6+xK_rightmiddlesummation :: KeyVal+xK_rightmiddlesummation = 0x8b7+xK_lessthanequal :: KeyVal+xK_lessthanequal = 0x8bc+xK_notequal :: KeyVal+xK_notequal = 0x8bd+xK_greaterthanequal :: KeyVal+xK_greaterthanequal = 0x8be+xK_integral :: KeyVal+xK_integral = 0x8bf+xK_therefore :: KeyVal+xK_therefore = 0x8c0+xK_variation :: KeyVal+xK_variation = 0x8c1+xK_infinity :: KeyVal+xK_infinity = 0x8c2+xK_nabla :: KeyVal+xK_nabla = 0x8c5+xK_approximate :: KeyVal+xK_approximate = 0x8c8+xK_similarequal :: KeyVal+xK_similarequal = 0x8c9+xK_ifonlyif :: KeyVal+xK_ifonlyif = 0x8cd+xK_implies :: KeyVal+xK_implies = 0x8ce+xK_identical :: KeyVal+xK_identical = 0x8cf+xK_radical :: KeyVal+xK_radical = 0x8d6+xK_includedin :: KeyVal+xK_includedin = 0x8da+xK_includes :: KeyVal+xK_includes = 0x8db+xK_intersection :: KeyVal+xK_intersection = 0x8dc+xK_union :: KeyVal+xK_union = 0x8dd+xK_logicaland :: KeyVal+xK_logicaland = 0x8de+xK_logicalor :: KeyVal+xK_logicalor = 0x8df+xK_partialderivative :: KeyVal+xK_partialderivative = 0x8ef+xK_function :: KeyVal+xK_function = 0x8f6+xK_leftarrow :: KeyVal+xK_leftarrow = 0x8fb+xK_uparrow :: KeyVal+xK_uparrow = 0x8fc+xK_rightarrow :: KeyVal+xK_rightarrow = 0x8fd+xK_downarrow :: KeyVal+xK_downarrow = 0x8fe+xK_blank :: KeyVal+xK_blank = 0x9df+xK_soliddiamond :: KeyVal+xK_soliddiamond = 0x9e0+xK_checkerboard :: KeyVal+xK_checkerboard = 0x9e1+xK_ht :: KeyVal+xK_ht = 0x9e2+xK_ff :: KeyVal+xK_ff = 0x9e3+xK_cr :: KeyVal+xK_cr = 0x9e4+xK_lf :: KeyVal+xK_lf = 0x9e5+xK_nl :: KeyVal+xK_nl = 0x9e8+xK_vt :: KeyVal+xK_vt = 0x9e9+xK_lowrightcorner :: KeyVal+xK_lowrightcorner = 0x9ea+xK_uprightcorner :: KeyVal+xK_uprightcorner = 0x9eb+xK_upleftcorner :: KeyVal+xK_upleftcorner = 0x9ec+xK_lowleftcorner :: KeyVal+xK_lowleftcorner = 0x9ed+xK_crossinglines :: KeyVal+xK_crossinglines = 0x9ee+xK_horizlinescan1 :: KeyVal+xK_horizlinescan1 = 0x9ef+xK_horizlinescan3 :: KeyVal+xK_horizlinescan3 = 0x9f0+xK_horizlinescan5 :: KeyVal+xK_horizlinescan5 = 0x9f1+xK_horizlinescan7 :: KeyVal+xK_horizlinescan7 = 0x9f2+xK_horizlinescan9 :: KeyVal+xK_horizlinescan9 = 0x9f3+xK_leftt :: KeyVal+xK_leftt = 0x9f4+xK_rightt :: KeyVal+xK_rightt = 0x9f5+xK_bott :: KeyVal+xK_bott = 0x9f6+xK_topt :: KeyVal+xK_topt = 0x9f7+xK_vertbar :: KeyVal+xK_vertbar = 0x9f8+xK_emspace :: KeyVal+xK_emspace = 0xaa1+xK_enspace :: KeyVal+xK_enspace = 0xaa2+xK_em3space :: KeyVal+xK_em3space = 0xaa3+xK_em4space :: KeyVal+xK_em4space = 0xaa4+xK_digitspace :: KeyVal+xK_digitspace = 0xaa5+xK_punctspace :: KeyVal+xK_punctspace = 0xaa6+xK_thinspace :: KeyVal+xK_thinspace = 0xaa7+xK_hairspace :: KeyVal+xK_hairspace = 0xaa8+xK_emdash :: KeyVal+xK_emdash = 0xaa9+xK_endash :: KeyVal+xK_endash = 0xaaa+xK_signifblank :: KeyVal+xK_signifblank = 0xaac+xK_ellipsis :: KeyVal+xK_ellipsis = 0xaae+xK_doubbaselinedot :: KeyVal+xK_doubbaselinedot = 0xaaf+xK_onethird :: KeyVal+xK_onethird = 0xab0+xK_twothirds :: KeyVal+xK_twothirds = 0xab1+xK_onefifth :: KeyVal+xK_onefifth = 0xab2+xK_twofifths :: KeyVal+xK_twofifths = 0xab3+xK_threefifths :: KeyVal+xK_threefifths = 0xab4+xK_fourfifths :: KeyVal+xK_fourfifths = 0xab5+xK_onesixth :: KeyVal+xK_onesixth = 0xab6+xK_fivesixths :: KeyVal+xK_fivesixths = 0xab7+xK_careof :: KeyVal+xK_careof = 0xab8+xK_figdash :: KeyVal+xK_figdash = 0xabb+xK_leftanglebracket :: KeyVal+xK_leftanglebracket = 0xabc+xK_decimalpoint :: KeyVal+xK_decimalpoint = 0xabd+xK_rightanglebracket :: KeyVal+xK_rightanglebracket = 0xabe+xK_marker :: KeyVal+xK_marker = 0xabf+xK_oneeighth :: KeyVal+xK_oneeighth = 0xac3+xK_threeeighths :: KeyVal+xK_threeeighths = 0xac4+xK_fiveeighths :: KeyVal+xK_fiveeighths = 0xac5+xK_seveneighths :: KeyVal+xK_seveneighths = 0xac6+xK_trademark :: KeyVal+xK_trademark = 0xac9+xK_signaturemark :: KeyVal+xK_signaturemark = 0xaca+xK_trademarkincircle :: KeyVal+xK_trademarkincircle = 0xacb+xK_leftopentriangle :: KeyVal+xK_leftopentriangle = 0xacc+xK_rightopentriangle :: KeyVal+xK_rightopentriangle = 0xacd+xK_emopencircle :: KeyVal+xK_emopencircle = 0xace+xK_emopenrectangle :: KeyVal+xK_emopenrectangle = 0xacf+xK_leftsinglequotemark :: KeyVal+xK_leftsinglequotemark = 0xad0+xK_rightsinglequotemark :: KeyVal+xK_rightsinglequotemark = 0xad1+xK_leftdoublequotemark :: KeyVal+xK_leftdoublequotemark = 0xad2+xK_rightdoublequotemark :: KeyVal+xK_rightdoublequotemark = 0xad3+xK_prescription :: KeyVal+xK_prescription = 0xad4+xK_permille :: KeyVal+xK_permille = 0xad5+xK_minutes :: KeyVal+xK_minutes = 0xad6+xK_seconds :: KeyVal+xK_seconds = 0xad7+xK_latincross :: KeyVal+xK_latincross = 0xad9+xK_hexagram :: KeyVal+xK_hexagram = 0xada+xK_filledrectbullet :: KeyVal+xK_filledrectbullet = 0xadb+xK_filledlefttribullet :: KeyVal+xK_filledlefttribullet = 0xadc+xK_filledrighttribullet :: KeyVal+xK_filledrighttribullet = 0xadd+xK_emfilledcircle :: KeyVal+xK_emfilledcircle = 0xade+xK_emfilledrect :: KeyVal+xK_emfilledrect = 0xadf+xK_enopencircbullet :: KeyVal+xK_enopencircbullet = 0xae0+xK_enopensquarebullet :: KeyVal+xK_enopensquarebullet = 0xae1+xK_openrectbullet :: KeyVal+xK_openrectbullet = 0xae2+xK_opentribulletup :: KeyVal+xK_opentribulletup = 0xae3+xK_opentribulletdown :: KeyVal+xK_opentribulletdown = 0xae4+xK_openstar :: KeyVal+xK_openstar = 0xae5+xK_enfilledcircbullet :: KeyVal+xK_enfilledcircbullet = 0xae6+xK_enfilledsqbullet :: KeyVal+xK_enfilledsqbullet = 0xae7+xK_filledtribulletup :: KeyVal+xK_filledtribulletup = 0xae8+xK_filledtribulletdown :: KeyVal+xK_filledtribulletdown = 0xae9+xK_leftpointer :: KeyVal+xK_leftpointer = 0xaea+xK_rightpointer :: KeyVal+xK_rightpointer = 0xaeb+xK_club :: KeyVal+xK_club = 0xaec+xK_diamond :: KeyVal+xK_diamond = 0xaed+xK_heart :: KeyVal+xK_heart = 0xaee+xK_maltesecross :: KeyVal+xK_maltesecross = 0xaf0+xK_dagger :: KeyVal+xK_dagger = 0xaf1+xK_doubledagger :: KeyVal+xK_doubledagger = 0xaf2+xK_checkmark :: KeyVal+xK_checkmark = 0xaf3+xK_ballotcross :: KeyVal+xK_ballotcross = 0xaf4+xK_musicalsharp :: KeyVal+xK_musicalsharp = 0xaf5+xK_musicalflat :: KeyVal+xK_musicalflat = 0xaf6+xK_malesymbol :: KeyVal+xK_malesymbol = 0xaf7+xK_femalesymbol :: KeyVal+xK_femalesymbol = 0xaf8+xK_telephone :: KeyVal+xK_telephone = 0xaf9+xK_telephonerecorder :: KeyVal+xK_telephonerecorder = 0xafa+xK_phonographcopyright :: KeyVal+xK_phonographcopyright = 0xafb+xK_caret :: KeyVal+xK_caret = 0xafc+xK_singlelowquotemark :: KeyVal+xK_singlelowquotemark = 0xafd+xK_doublelowquotemark :: KeyVal+xK_doublelowquotemark = 0xafe+xK_cursor :: KeyVal+xK_cursor = 0xaff+xK_leftcaret :: KeyVal+xK_leftcaret = 0xba3+xK_rightcaret :: KeyVal+xK_rightcaret = 0xba6+xK_downcaret :: KeyVal+xK_downcaret = 0xba8+xK_upcaret :: KeyVal+xK_upcaret = 0xba9+xK_overbar :: KeyVal+xK_overbar = 0xbc0+xK_downtack :: KeyVal+xK_downtack = 0xbc2+xK_upshoe :: KeyVal+xK_upshoe = 0xbc3+xK_downstile :: KeyVal+xK_downstile = 0xbc4+xK_underbar :: KeyVal+xK_underbar = 0xbc6+xK_jot :: KeyVal+xK_jot = 0xbca+xK_quad :: KeyVal+xK_quad = 0xbcc+xK_uptack :: KeyVal+xK_uptack = 0xbce+xK_circle :: KeyVal+xK_circle = 0xbcf+xK_upstile :: KeyVal+xK_upstile = 0xbd3+xK_downshoe :: KeyVal+xK_downshoe = 0xbd6+xK_rightshoe :: KeyVal+xK_rightshoe = 0xbd8+xK_leftshoe :: KeyVal+xK_leftshoe = 0xbda+xK_lefttack :: KeyVal+xK_lefttack = 0xbdc+xK_righttack :: KeyVal+xK_righttack = 0xbfc+xK_hebrew_doublelowline :: KeyVal+xK_hebrew_doublelowline = 0xcdf+xK_hebrew_aleph :: KeyVal+xK_hebrew_aleph = 0xce0+xK_hebrew_bet :: KeyVal+xK_hebrew_bet = 0xce1+xK_hebrew_beth :: KeyVal+xK_hebrew_beth = 0xce1+xK_hebrew_gimel :: KeyVal+xK_hebrew_gimel = 0xce2+xK_hebrew_gimmel :: KeyVal+xK_hebrew_gimmel = 0xce2+xK_hebrew_dalet :: KeyVal+xK_hebrew_dalet = 0xce3+xK_hebrew_daleth :: KeyVal+xK_hebrew_daleth = 0xce3+xK_hebrew_he :: KeyVal+xK_hebrew_he = 0xce4+xK_hebrew_waw :: KeyVal+xK_hebrew_waw = 0xce5+xK_hebrew_zain :: KeyVal+xK_hebrew_zain = 0xce6+xK_hebrew_zayin :: KeyVal+xK_hebrew_zayin = 0xce6+xK_hebrew_chet :: KeyVal+xK_hebrew_chet = 0xce7+xK_hebrew_het :: KeyVal+xK_hebrew_het = 0xce7+xK_hebrew_tet :: KeyVal+xK_hebrew_tet = 0xce8+xK_hebrew_teth :: KeyVal+xK_hebrew_teth = 0xce8+xK_hebrew_yod :: KeyVal+xK_hebrew_yod = 0xce9+xK_hebrew_finalkaph :: KeyVal+xK_hebrew_finalkaph = 0xcea+xK_hebrew_kaph :: KeyVal+xK_hebrew_kaph = 0xceb+xK_hebrew_lamed :: KeyVal+xK_hebrew_lamed = 0xcec+xK_hebrew_finalmem :: KeyVal+xK_hebrew_finalmem = 0xced+xK_hebrew_mem :: KeyVal+xK_hebrew_mem = 0xcee+xK_hebrew_finalnun :: KeyVal+xK_hebrew_finalnun = 0xcef+xK_hebrew_nun :: KeyVal+xK_hebrew_nun = 0xcf0+xK_hebrew_samech :: KeyVal+xK_hebrew_samech = 0xcf1+xK_hebrew_samekh :: KeyVal+xK_hebrew_samekh = 0xcf1+xK_hebrew_ayin :: KeyVal+xK_hebrew_ayin = 0xcf2+xK_hebrew_finalpe :: KeyVal+xK_hebrew_finalpe = 0xcf3+xK_hebrew_pe :: KeyVal+xK_hebrew_pe = 0xcf4+xK_hebrew_finalzade :: KeyVal+xK_hebrew_finalzade = 0xcf5+xK_hebrew_finalzadi :: KeyVal+xK_hebrew_finalzadi = 0xcf5+xK_hebrew_zade :: KeyVal+xK_hebrew_zade = 0xcf6+xK_hebrew_zadi :: KeyVal+xK_hebrew_zadi = 0xcf6+xK_hebrew_qoph :: KeyVal+xK_hebrew_qoph = 0xcf7+xK_hebrew_kuf :: KeyVal+xK_hebrew_kuf = 0xcf7+xK_hebrew_resh :: KeyVal+xK_hebrew_resh = 0xcf8+xK_hebrew_shin :: KeyVal+xK_hebrew_shin = 0xcf9+xK_hebrew_taw :: KeyVal+xK_hebrew_taw = 0xcfa+xK_hebrew_taf :: KeyVal+xK_hebrew_taf = 0xcfa+xK_Hebrew_switch :: KeyVal+xK_Hebrew_switch = 0xff7e+xK_Thai_kokai :: KeyVal+xK_Thai_kokai = 0xda1+xK_Thai_khokhai :: KeyVal+xK_Thai_khokhai = 0xda2+xK_Thai_khokhuat :: KeyVal+xK_Thai_khokhuat = 0xda3+xK_Thai_khokhwai :: KeyVal+xK_Thai_khokhwai = 0xda4+xK_Thai_khokhon :: KeyVal+xK_Thai_khokhon = 0xda5+xK_Thai_khorakhang :: KeyVal+xK_Thai_khorakhang = 0xda6+xK_Thai_ngongu :: KeyVal+xK_Thai_ngongu = 0xda7+xK_Thai_chochan :: KeyVal+xK_Thai_chochan = 0xda8+xK_Thai_choching :: KeyVal+xK_Thai_choching = 0xda9+xK_Thai_chochang :: KeyVal+xK_Thai_chochang = 0xdaa+xK_Thai_soso :: KeyVal+xK_Thai_soso = 0xdab+xK_Thai_chochoe :: KeyVal+xK_Thai_chochoe = 0xdac+xK_Thai_yoying :: KeyVal+xK_Thai_yoying = 0xdad+xK_Thai_dochada :: KeyVal+xK_Thai_dochada = 0xdae+xK_Thai_topatak :: KeyVal+xK_Thai_topatak = 0xdaf+xK_Thai_thothan :: KeyVal+xK_Thai_thothan = 0xdb0+xK_Thai_thonangmontho :: KeyVal+xK_Thai_thonangmontho = 0xdb1+xK_Thai_thophuthao :: KeyVal+xK_Thai_thophuthao = 0xdb2+xK_Thai_nonen :: KeyVal+xK_Thai_nonen = 0xdb3+xK_Thai_dodek :: KeyVal+xK_Thai_dodek = 0xdb4+xK_Thai_totao :: KeyVal+xK_Thai_totao = 0xdb5+xK_Thai_thothung :: KeyVal+xK_Thai_thothung = 0xdb6+xK_Thai_thothahan :: KeyVal+xK_Thai_thothahan = 0xdb7+xK_Thai_thothong :: KeyVal+xK_Thai_thothong = 0xdb8+xK_Thai_nonu :: KeyVal+xK_Thai_nonu = 0xdb9+xK_Thai_bobaimai :: KeyVal+xK_Thai_bobaimai = 0xdba+xK_Thai_popla :: KeyVal+xK_Thai_popla = 0xdbb+xK_Thai_phophung :: KeyVal+xK_Thai_phophung = 0xdbc+xK_Thai_fofa :: KeyVal+xK_Thai_fofa = 0xdbd+xK_Thai_phophan :: KeyVal+xK_Thai_phophan = 0xdbe+xK_Thai_fofan :: KeyVal+xK_Thai_fofan = 0xdbf+xK_Thai_phosamphao :: KeyVal+xK_Thai_phosamphao = 0xdc0+xK_Thai_moma :: KeyVal+xK_Thai_moma = 0xdc1+xK_Thai_yoyak :: KeyVal+xK_Thai_yoyak = 0xdc2+xK_Thai_rorua :: KeyVal+xK_Thai_rorua = 0xdc3+xK_Thai_ru :: KeyVal+xK_Thai_ru = 0xdc4+xK_Thai_loling :: KeyVal+xK_Thai_loling = 0xdc5+xK_Thai_lu :: KeyVal+xK_Thai_lu = 0xdc6+xK_Thai_wowaen :: KeyVal+xK_Thai_wowaen = 0xdc7+xK_Thai_sosala :: KeyVal+xK_Thai_sosala = 0xdc8+xK_Thai_sorusi :: KeyVal+xK_Thai_sorusi = 0xdc9+xK_Thai_sosua :: KeyVal+xK_Thai_sosua = 0xdca+xK_Thai_hohip :: KeyVal+xK_Thai_hohip = 0xdcb+xK_Thai_lochula :: KeyVal+xK_Thai_lochula = 0xdcc+xK_Thai_oang :: KeyVal+xK_Thai_oang = 0xdcd+xK_Thai_honokhuk :: KeyVal+xK_Thai_honokhuk = 0xdce+xK_Thai_paiyannoi :: KeyVal+xK_Thai_paiyannoi = 0xdcf+xK_Thai_saraa :: KeyVal+xK_Thai_saraa = 0xdd0+xK_Thai_maihanakat :: KeyVal+xK_Thai_maihanakat = 0xdd1+xK_Thai_saraaa :: KeyVal+xK_Thai_saraaa = 0xdd2+xK_Thai_saraam :: KeyVal+xK_Thai_saraam = 0xdd3+xK_Thai_sarai :: KeyVal+xK_Thai_sarai = 0xdd4+xK_Thai_saraii :: KeyVal+xK_Thai_saraii = 0xdd5+xK_Thai_saraue :: KeyVal+xK_Thai_saraue = 0xdd6+xK_Thai_sarauee :: KeyVal+xK_Thai_sarauee = 0xdd7+xK_Thai_sarau :: KeyVal+xK_Thai_sarau = 0xdd8+xK_Thai_sarauu :: KeyVal+xK_Thai_sarauu = 0xdd9+xK_Thai_phinthu :: KeyVal+xK_Thai_phinthu = 0xdda+xK_Thai_maihanakat_maitho :: KeyVal+xK_Thai_maihanakat_maitho = 0xdde+xK_Thai_baht :: KeyVal+xK_Thai_baht = 0xddf+xK_Thai_sarae :: KeyVal+xK_Thai_sarae = 0xde0+xK_Thai_saraae :: KeyVal+xK_Thai_saraae = 0xde1+xK_Thai_sarao :: KeyVal+xK_Thai_sarao = 0xde2+xK_Thai_saraaimaimuan :: KeyVal+xK_Thai_saraaimaimuan = 0xde3+xK_Thai_saraaimaimalai :: KeyVal+xK_Thai_saraaimaimalai = 0xde4+xK_Thai_lakkhangyao :: KeyVal+xK_Thai_lakkhangyao = 0xde5+xK_Thai_maiyamok :: KeyVal+xK_Thai_maiyamok = 0xde6+xK_Thai_maitaikhu :: KeyVal+xK_Thai_maitaikhu = 0xde7+xK_Thai_maiek :: KeyVal+xK_Thai_maiek = 0xde8+xK_Thai_maitho :: KeyVal+xK_Thai_maitho = 0xde9+xK_Thai_maitri :: KeyVal+xK_Thai_maitri = 0xdea+xK_Thai_maichattawa :: KeyVal+xK_Thai_maichattawa = 0xdeb+xK_Thai_thanthakhat :: KeyVal+xK_Thai_thanthakhat = 0xdec+xK_Thai_nikhahit :: KeyVal+xK_Thai_nikhahit = 0xded+xK_Thai_leksun :: KeyVal+xK_Thai_leksun = 0xdf0+xK_Thai_leknung :: KeyVal+xK_Thai_leknung = 0xdf1+xK_Thai_leksong :: KeyVal+xK_Thai_leksong = 0xdf2+xK_Thai_leksam :: KeyVal+xK_Thai_leksam = 0xdf3+xK_Thai_leksi :: KeyVal+xK_Thai_leksi = 0xdf4+xK_Thai_lekha :: KeyVal+xK_Thai_lekha = 0xdf5+xK_Thai_lekhok :: KeyVal+xK_Thai_lekhok = 0xdf6+xK_Thai_lekchet :: KeyVal+xK_Thai_lekchet = 0xdf7+xK_Thai_lekpaet :: KeyVal+xK_Thai_lekpaet = 0xdf8+xK_Thai_lekkao :: KeyVal+xK_Thai_lekkao = 0xdf9+xK_Hangul :: KeyVal+xK_Hangul = 0xff31+xK_Hangul_Start :: KeyVal+xK_Hangul_Start = 0xff32+xK_Hangul_End :: KeyVal+xK_Hangul_End = 0xff33+xK_Hangul_Hanja :: KeyVal+xK_Hangul_Hanja = 0xff34+xK_Hangul_Jamo :: KeyVal+xK_Hangul_Jamo = 0xff35+xK_Hangul_Romaja :: KeyVal+xK_Hangul_Romaja = 0xff36+xK_Hangul_Codeinput :: KeyVal+xK_Hangul_Codeinput = 0xff37+xK_Hangul_Jeonja :: KeyVal+xK_Hangul_Jeonja = 0xff38+xK_Hangul_Banja :: KeyVal+xK_Hangul_Banja = 0xff39+xK_Hangul_PreHanja :: KeyVal+xK_Hangul_PreHanja = 0xff3a+xK_Hangul_PostHanja :: KeyVal+xK_Hangul_PostHanja = 0xff3b+xK_Hangul_SingleCandidate :: KeyVal+xK_Hangul_SingleCandidate = 0xff3c+xK_Hangul_MultipleCandidate :: KeyVal+xK_Hangul_MultipleCandidate = 0xff3d+xK_Hangul_PreviousCandidate :: KeyVal+xK_Hangul_PreviousCandidate = 0xff3e+xK_Hangul_Special :: KeyVal+xK_Hangul_Special = 0xff3f+xK_Hangul_switch :: KeyVal+xK_Hangul_switch = 0xff7e+xK_Hangul_Kiyeog :: KeyVal+xK_Hangul_Kiyeog = 0xea1+xK_Hangul_SsangKiyeog :: KeyVal+xK_Hangul_SsangKiyeog = 0xea2+xK_Hangul_KiyeogSios :: KeyVal+xK_Hangul_KiyeogSios = 0xea3+xK_Hangul_Nieun :: KeyVal+xK_Hangul_Nieun = 0xea4+xK_Hangul_NieunJieuj :: KeyVal+xK_Hangul_NieunJieuj = 0xea5+xK_Hangul_NieunHieuh :: KeyVal+xK_Hangul_NieunHieuh = 0xea6+xK_Hangul_Dikeud :: KeyVal+xK_Hangul_Dikeud = 0xea7+xK_Hangul_SsangDikeud :: KeyVal+xK_Hangul_SsangDikeud = 0xea8+xK_Hangul_Rieul :: KeyVal+xK_Hangul_Rieul = 0xea9+xK_Hangul_RieulKiyeog :: KeyVal+xK_Hangul_RieulKiyeog = 0xeaa+xK_Hangul_RieulMieum :: KeyVal+xK_Hangul_RieulMieum = 0xeab+xK_Hangul_RieulPieub :: KeyVal+xK_Hangul_RieulPieub = 0xeac+xK_Hangul_RieulSios :: KeyVal+xK_Hangul_RieulSios = 0xead+xK_Hangul_RieulTieut :: KeyVal+xK_Hangul_RieulTieut = 0xeae+xK_Hangul_RieulPhieuf :: KeyVal+xK_Hangul_RieulPhieuf = 0xeaf+xK_Hangul_RieulHieuh :: KeyVal+xK_Hangul_RieulHieuh = 0xeb0+xK_Hangul_Mieum :: KeyVal+xK_Hangul_Mieum = 0xeb1+xK_Hangul_Pieub :: KeyVal+xK_Hangul_Pieub = 0xeb2+xK_Hangul_SsangPieub :: KeyVal+xK_Hangul_SsangPieub = 0xeb3+xK_Hangul_PieubSios :: KeyVal+xK_Hangul_PieubSios = 0xeb4+xK_Hangul_Sios :: KeyVal+xK_Hangul_Sios = 0xeb5+xK_Hangul_SsangSios :: KeyVal+xK_Hangul_SsangSios = 0xeb6+xK_Hangul_Ieung :: KeyVal+xK_Hangul_Ieung = 0xeb7+xK_Hangul_Jieuj :: KeyVal+xK_Hangul_Jieuj = 0xeb8+xK_Hangul_SsangJieuj :: KeyVal+xK_Hangul_SsangJieuj = 0xeb9+xK_Hangul_Cieuc :: KeyVal+xK_Hangul_Cieuc = 0xeba+xK_Hangul_Khieuq :: KeyVal+xK_Hangul_Khieuq = 0xebb+xK_Hangul_Tieut :: KeyVal+xK_Hangul_Tieut = 0xebc+xK_Hangul_Phieuf :: KeyVal+xK_Hangul_Phieuf = 0xebd+xK_Hangul_Hieuh :: KeyVal+xK_Hangul_Hieuh = 0xebe+xK_Hangul_A :: KeyVal+xK_Hangul_A = 0xebf+xK_Hangul_AE :: KeyVal+xK_Hangul_AE = 0xec0+xK_Hangul_YA :: KeyVal+xK_Hangul_YA = 0xec1+xK_Hangul_YAE :: KeyVal+xK_Hangul_YAE = 0xec2+xK_Hangul_EO :: KeyVal+xK_Hangul_EO = 0xec3+xK_Hangul_E :: KeyVal+xK_Hangul_E = 0xec4+xK_Hangul_YEO :: KeyVal+xK_Hangul_YEO = 0xec5+xK_Hangul_YE :: KeyVal+xK_Hangul_YE = 0xec6+xK_Hangul_O :: KeyVal+xK_Hangul_O = 0xec7+xK_Hangul_WA :: KeyVal+xK_Hangul_WA = 0xec8+xK_Hangul_WAE :: KeyVal+xK_Hangul_WAE = 0xec9+xK_Hangul_OE :: KeyVal+xK_Hangul_OE = 0xeca+xK_Hangul_YO :: KeyVal+xK_Hangul_YO = 0xecb+xK_Hangul_U :: KeyVal+xK_Hangul_U = 0xecc+xK_Hangul_WEO :: KeyVal+xK_Hangul_WEO = 0xecd+xK_Hangul_WE :: KeyVal+xK_Hangul_WE = 0xece+xK_Hangul_WI :: KeyVal+xK_Hangul_WI = 0xecf+xK_Hangul_YU :: KeyVal+xK_Hangul_YU = 0xed0+xK_Hangul_EU :: KeyVal+xK_Hangul_EU = 0xed1+xK_Hangul_YI :: KeyVal+xK_Hangul_YI = 0xed2+xK_Hangul_I :: KeyVal+xK_Hangul_I = 0xed3+xK_Hangul_J_Kiyeog :: KeyVal+xK_Hangul_J_Kiyeog = 0xed4+xK_Hangul_J_SsangKiyeog :: KeyVal+xK_Hangul_J_SsangKiyeog = 0xed5+xK_Hangul_J_KiyeogSios :: KeyVal+xK_Hangul_J_KiyeogSios = 0xed6+xK_Hangul_J_Nieun :: KeyVal+xK_Hangul_J_Nieun = 0xed7+xK_Hangul_J_NieunJieuj :: KeyVal+xK_Hangul_J_NieunJieuj = 0xed8+xK_Hangul_J_NieunHieuh :: KeyVal+xK_Hangul_J_NieunHieuh = 0xed9+xK_Hangul_J_Dikeud :: KeyVal+xK_Hangul_J_Dikeud = 0xeda+xK_Hangul_J_Rieul :: KeyVal+xK_Hangul_J_Rieul = 0xedb+xK_Hangul_J_RieulKiyeog :: KeyVal+xK_Hangul_J_RieulKiyeog = 0xedc+xK_Hangul_J_RieulMieum :: KeyVal+xK_Hangul_J_RieulMieum = 0xedd+xK_Hangul_J_RieulPieub :: KeyVal+xK_Hangul_J_RieulPieub = 0xede+xK_Hangul_J_RieulSios :: KeyVal+xK_Hangul_J_RieulSios = 0xedf+xK_Hangul_J_RieulTieut :: KeyVal+xK_Hangul_J_RieulTieut = 0xee0+xK_Hangul_J_RieulPhieuf :: KeyVal+xK_Hangul_J_RieulPhieuf = 0xee1+xK_Hangul_J_RieulHieuh :: KeyVal+xK_Hangul_J_RieulHieuh = 0xee2+xK_Hangul_J_Mieum :: KeyVal+xK_Hangul_J_Mieum = 0xee3+xK_Hangul_J_Pieub :: KeyVal+xK_Hangul_J_Pieub = 0xee4+xK_Hangul_J_PieubSios :: KeyVal+xK_Hangul_J_PieubSios = 0xee5+xK_Hangul_J_Sios :: KeyVal+xK_Hangul_J_Sios = 0xee6+xK_Hangul_J_SsangSios :: KeyVal+xK_Hangul_J_SsangSios = 0xee7+xK_Hangul_J_Ieung :: KeyVal+xK_Hangul_J_Ieung = 0xee8+xK_Hangul_J_Jieuj :: KeyVal+xK_Hangul_J_Jieuj = 0xee9+xK_Hangul_J_Cieuc :: KeyVal+xK_Hangul_J_Cieuc = 0xeea+xK_Hangul_J_Khieuq :: KeyVal+xK_Hangul_J_Khieuq = 0xeeb+xK_Hangul_J_Tieut :: KeyVal+xK_Hangul_J_Tieut = 0xeec+xK_Hangul_J_Phieuf :: KeyVal+xK_Hangul_J_Phieuf = 0xeed+xK_Hangul_J_Hieuh :: KeyVal+xK_Hangul_J_Hieuh = 0xeee+xK_Hangul_RieulYeorinHieuh :: KeyVal+xK_Hangul_RieulYeorinHieuh = 0xeef+xK_Hangul_SunkyeongeumMieum :: KeyVal+xK_Hangul_SunkyeongeumMieum = 0xef0+xK_Hangul_SunkyeongeumPieub :: KeyVal+xK_Hangul_SunkyeongeumPieub = 0xef1+xK_Hangul_PanSios :: KeyVal+xK_Hangul_PanSios = 0xef2+xK_Hangul_KkogjiDalrinIeung :: KeyVal+xK_Hangul_KkogjiDalrinIeung = 0xef3+xK_Hangul_SunkyeongeumPhieuf :: KeyVal+xK_Hangul_SunkyeongeumPhieuf = 0xef4+xK_Hangul_YeorinHieuh :: KeyVal+xK_Hangul_YeorinHieuh = 0xef5+xK_Hangul_AraeA :: KeyVal+xK_Hangul_AraeA = 0xef6+xK_Hangul_AraeAE :: KeyVal+xK_Hangul_AraeAE = 0xef7+xK_Hangul_J_PanSios :: KeyVal+xK_Hangul_J_PanSios = 0xef8+xK_Hangul_J_KkogjiDalrinIeung :: KeyVal+xK_Hangul_J_KkogjiDalrinIeung = 0xef9+xK_Hangul_J_YeorinHieuh :: KeyVal+xK_Hangul_J_YeorinHieuh = 0xefa+xK_Korean_Won :: KeyVal+xK_Korean_Won = 0xeff+xK_Armenian_ligature_ew :: KeyVal+xK_Armenian_ligature_ew = 0x1000587+xK_Armenian_full_stop :: KeyVal+xK_Armenian_full_stop = 0x1000589+xK_Armenian_verjaket :: KeyVal+xK_Armenian_verjaket = 0x1000589+xK_Armenian_separation_mark :: KeyVal+xK_Armenian_separation_mark = 0x100055d+xK_Armenian_but :: KeyVal+xK_Armenian_but = 0x100055d+xK_Armenian_hyphen :: KeyVal+xK_Armenian_hyphen = 0x100058a+xK_Armenian_yentamna :: KeyVal+xK_Armenian_yentamna = 0x100058a+xK_Armenian_exclam :: KeyVal+xK_Armenian_exclam = 0x100055c+xK_Armenian_amanak :: KeyVal+xK_Armenian_amanak = 0x100055c+xK_Armenian_accent :: KeyVal+xK_Armenian_accent = 0x100055b+xK_Armenian_shesht :: KeyVal+xK_Armenian_shesht = 0x100055b+xK_Armenian_question :: KeyVal+xK_Armenian_question = 0x100055e+xK_Armenian_paruyk :: KeyVal+xK_Armenian_paruyk = 0x100055e+xK_Armenian_AYB :: KeyVal+xK_Armenian_AYB = 0x1000531+xK_Armenian_ayb :: KeyVal+xK_Armenian_ayb = 0x1000561+xK_Armenian_BEN :: KeyVal+xK_Armenian_BEN = 0x1000532+xK_Armenian_ben :: KeyVal+xK_Armenian_ben = 0x1000562+xK_Armenian_GIM :: KeyVal+xK_Armenian_GIM = 0x1000533+xK_Armenian_gim :: KeyVal+xK_Armenian_gim = 0x1000563+xK_Armenian_DA :: KeyVal+xK_Armenian_DA = 0x1000534+xK_Armenian_da :: KeyVal+xK_Armenian_da = 0x1000564+xK_Armenian_YECH :: KeyVal+xK_Armenian_YECH = 0x1000535+xK_Armenian_yech :: KeyVal+xK_Armenian_yech = 0x1000565+xK_Armenian_ZA :: KeyVal+xK_Armenian_ZA = 0x1000536+xK_Armenian_za :: KeyVal+xK_Armenian_za = 0x1000566+xK_Armenian_E :: KeyVal+xK_Armenian_E = 0x1000537+xK_Armenian_e :: KeyVal+xK_Armenian_e = 0x1000567+xK_Armenian_AT :: KeyVal+xK_Armenian_AT = 0x1000538+xK_Armenian_at :: KeyVal+xK_Armenian_at = 0x1000568+xK_Armenian_TO :: KeyVal+xK_Armenian_TO = 0x1000539+xK_Armenian_to :: KeyVal+xK_Armenian_to = 0x1000569+xK_Armenian_ZHE :: KeyVal+xK_Armenian_ZHE = 0x100053a+xK_Armenian_zhe :: KeyVal+xK_Armenian_zhe = 0x100056a+xK_Armenian_INI :: KeyVal+xK_Armenian_INI = 0x100053b+xK_Armenian_ini :: KeyVal+xK_Armenian_ini = 0x100056b+xK_Armenian_LYUN :: KeyVal+xK_Armenian_LYUN = 0x100053c+xK_Armenian_lyun :: KeyVal+xK_Armenian_lyun = 0x100056c+xK_Armenian_KHE :: KeyVal+xK_Armenian_KHE = 0x100053d+xK_Armenian_khe :: KeyVal+xK_Armenian_khe = 0x100056d+xK_Armenian_TSA :: KeyVal+xK_Armenian_TSA = 0x100053e+xK_Armenian_tsa :: KeyVal+xK_Armenian_tsa = 0x100056e+xK_Armenian_KEN :: KeyVal+xK_Armenian_KEN = 0x100053f+xK_Armenian_ken :: KeyVal+xK_Armenian_ken = 0x100056f+xK_Armenian_HO :: KeyVal+xK_Armenian_HO = 0x1000540+xK_Armenian_ho :: KeyVal+xK_Armenian_ho = 0x1000570+xK_Armenian_DZA :: KeyVal+xK_Armenian_DZA = 0x1000541+xK_Armenian_dza :: KeyVal+xK_Armenian_dza = 0x1000571+xK_Armenian_GHAT :: KeyVal+xK_Armenian_GHAT = 0x1000542+xK_Armenian_ghat :: KeyVal+xK_Armenian_ghat = 0x1000572+xK_Armenian_TCHE :: KeyVal+xK_Armenian_TCHE = 0x1000543+xK_Armenian_tche :: KeyVal+xK_Armenian_tche = 0x1000573+xK_Armenian_MEN :: KeyVal+xK_Armenian_MEN = 0x1000544+xK_Armenian_men :: KeyVal+xK_Armenian_men = 0x1000574+xK_Armenian_HI :: KeyVal+xK_Armenian_HI = 0x1000545+xK_Armenian_hi :: KeyVal+xK_Armenian_hi = 0x1000575+xK_Armenian_NU :: KeyVal+xK_Armenian_NU = 0x1000546+xK_Armenian_nu :: KeyVal+xK_Armenian_nu = 0x1000576+xK_Armenian_SHA :: KeyVal+xK_Armenian_SHA = 0x1000547+xK_Armenian_sha :: KeyVal+xK_Armenian_sha = 0x1000577+xK_Armenian_VO :: KeyVal+xK_Armenian_VO = 0x1000548+xK_Armenian_vo :: KeyVal+xK_Armenian_vo = 0x1000578+xK_Armenian_CHA :: KeyVal+xK_Armenian_CHA = 0x1000549+xK_Armenian_cha :: KeyVal+xK_Armenian_cha = 0x1000579+xK_Armenian_PE :: KeyVal+xK_Armenian_PE = 0x100054a+xK_Armenian_pe :: KeyVal+xK_Armenian_pe = 0x100057a+xK_Armenian_JE :: KeyVal+xK_Armenian_JE = 0x100054b+xK_Armenian_je :: KeyVal+xK_Armenian_je = 0x100057b+xK_Armenian_RA :: KeyVal+xK_Armenian_RA = 0x100054c+xK_Armenian_ra :: KeyVal+xK_Armenian_ra = 0x100057c+xK_Armenian_SE :: KeyVal+xK_Armenian_SE = 0x100054d+xK_Armenian_se :: KeyVal+xK_Armenian_se = 0x100057d+xK_Armenian_VEV :: KeyVal+xK_Armenian_VEV = 0x100054e+xK_Armenian_vev :: KeyVal+xK_Armenian_vev = 0x100057e+xK_Armenian_TYUN :: KeyVal+xK_Armenian_TYUN = 0x100054f+xK_Armenian_tyun :: KeyVal+xK_Armenian_tyun = 0x100057f+xK_Armenian_RE :: KeyVal+xK_Armenian_RE = 0x1000550+xK_Armenian_re :: KeyVal+xK_Armenian_re = 0x1000580+xK_Armenian_TSO :: KeyVal+xK_Armenian_TSO = 0x1000551+xK_Armenian_tso :: KeyVal+xK_Armenian_tso = 0x1000581+xK_Armenian_VYUN :: KeyVal+xK_Armenian_VYUN = 0x1000552+xK_Armenian_vyun :: KeyVal+xK_Armenian_vyun = 0x1000582+xK_Armenian_PYUR :: KeyVal+xK_Armenian_PYUR = 0x1000553+xK_Armenian_pyur :: KeyVal+xK_Armenian_pyur = 0x1000583+xK_Armenian_KE :: KeyVal+xK_Armenian_KE = 0x1000554+xK_Armenian_ke :: KeyVal+xK_Armenian_ke = 0x1000584+xK_Armenian_O :: KeyVal+xK_Armenian_O = 0x1000555+xK_Armenian_o :: KeyVal+xK_Armenian_o = 0x1000585+xK_Armenian_FE :: KeyVal+xK_Armenian_FE = 0x1000556+xK_Armenian_fe :: KeyVal+xK_Armenian_fe = 0x1000586+xK_Armenian_apostrophe :: KeyVal+xK_Armenian_apostrophe = 0x100055a+xK_Georgian_an :: KeyVal+xK_Georgian_an = 0x10010d0+xK_Georgian_ban :: KeyVal+xK_Georgian_ban = 0x10010d1+xK_Georgian_gan :: KeyVal+xK_Georgian_gan = 0x10010d2+xK_Georgian_don :: KeyVal+xK_Georgian_don = 0x10010d3+xK_Georgian_en :: KeyVal+xK_Georgian_en = 0x10010d4+xK_Georgian_vin :: KeyVal+xK_Georgian_vin = 0x10010d5+xK_Georgian_zen :: KeyVal+xK_Georgian_zen = 0x10010d6+xK_Georgian_tan :: KeyVal+xK_Georgian_tan = 0x10010d7+xK_Georgian_in :: KeyVal+xK_Georgian_in = 0x10010d8+xK_Georgian_kan :: KeyVal+xK_Georgian_kan = 0x10010d9+xK_Georgian_las :: KeyVal+xK_Georgian_las = 0x10010da+xK_Georgian_man :: KeyVal+xK_Georgian_man = 0x10010db+xK_Georgian_nar :: KeyVal+xK_Georgian_nar = 0x10010dc+xK_Georgian_on :: KeyVal+xK_Georgian_on = 0x10010dd+xK_Georgian_par :: KeyVal+xK_Georgian_par = 0x10010de+xK_Georgian_zhar :: KeyVal+xK_Georgian_zhar = 0x10010df+xK_Georgian_rae :: KeyVal+xK_Georgian_rae = 0x10010e0+xK_Georgian_san :: KeyVal+xK_Georgian_san = 0x10010e1+xK_Georgian_tar :: KeyVal+xK_Georgian_tar = 0x10010e2+xK_Georgian_un :: KeyVal+xK_Georgian_un = 0x10010e3+xK_Georgian_phar :: KeyVal+xK_Georgian_phar = 0x10010e4+xK_Georgian_khar :: KeyVal+xK_Georgian_khar = 0x10010e5+xK_Georgian_ghan :: KeyVal+xK_Georgian_ghan = 0x10010e6+xK_Georgian_qar :: KeyVal+xK_Georgian_qar = 0x10010e7+xK_Georgian_shin :: KeyVal+xK_Georgian_shin = 0x10010e8+xK_Georgian_chin :: KeyVal+xK_Georgian_chin = 0x10010e9+xK_Georgian_can :: KeyVal+xK_Georgian_can = 0x10010ea+xK_Georgian_jil :: KeyVal+xK_Georgian_jil = 0x10010eb+xK_Georgian_cil :: KeyVal+xK_Georgian_cil = 0x10010ec+xK_Georgian_char :: KeyVal+xK_Georgian_char = 0x10010ed+xK_Georgian_xan :: KeyVal+xK_Georgian_xan = 0x10010ee+xK_Georgian_jhan :: KeyVal+xK_Georgian_jhan = 0x10010ef+xK_Georgian_hae :: KeyVal+xK_Georgian_hae = 0x10010f0+xK_Georgian_he :: KeyVal+xK_Georgian_he = 0x10010f1+xK_Georgian_hie :: KeyVal+xK_Georgian_hie = 0x10010f2+xK_Georgian_we :: KeyVal+xK_Georgian_we = 0x10010f3+xK_Georgian_har :: KeyVal+xK_Georgian_har = 0x10010f4+xK_Georgian_hoe :: KeyVal+xK_Georgian_hoe = 0x10010f5+xK_Georgian_fi :: KeyVal+xK_Georgian_fi = 0x10010f6+xK_Xabovedot :: KeyVal+xK_Xabovedot = 0x1001e8a+xK_Ibreve :: KeyVal+xK_Ibreve = 0x100012c+xK_Zstroke :: KeyVal+xK_Zstroke = 0x10001b5+xK_Gcaron :: KeyVal+xK_Gcaron = 0x10001e6+xK_Ocaron :: KeyVal+xK_Ocaron = 0x10001d1+xK_Obarred :: KeyVal+xK_Obarred = 0x100019f+xK_xabovedot :: KeyVal+xK_xabovedot = 0x1001e8b+xK_ibreve :: KeyVal+xK_ibreve = 0x100012d+xK_zstroke :: KeyVal+xK_zstroke = 0x10001b6+xK_gcaron :: KeyVal+xK_gcaron = 0x10001e7+xK_ocaron :: KeyVal+xK_ocaron = 0x10001d2+xK_obarred :: KeyVal+xK_obarred = 0x1000275+xK_SCHWA :: KeyVal+xK_SCHWA = 0x100018f+xK_schwa :: KeyVal+xK_schwa = 0x1000259+xK_EZH :: KeyVal+xK_EZH = 0x10001b7+xK_ezh :: KeyVal+xK_ezh = 0x1000292+xK_Lbelowdot :: KeyVal+xK_Lbelowdot = 0x1001e36+xK_lbelowdot :: KeyVal+xK_lbelowdot = 0x1001e37+xK_Abelowdot :: KeyVal+xK_Abelowdot = 0x1001ea0+xK_abelowdot :: KeyVal+xK_abelowdot = 0x1001ea1+xK_Ahook :: KeyVal+xK_Ahook = 0x1001ea2+xK_ahook :: KeyVal+xK_ahook = 0x1001ea3+xK_Acircumflexacute :: KeyVal+xK_Acircumflexacute = 0x1001ea4+xK_acircumflexacute :: KeyVal+xK_acircumflexacute = 0x1001ea5+xK_Acircumflexgrave :: KeyVal+xK_Acircumflexgrave = 0x1001ea6+xK_acircumflexgrave :: KeyVal+xK_acircumflexgrave = 0x1001ea7+xK_Acircumflexhook :: KeyVal+xK_Acircumflexhook = 0x1001ea8+xK_acircumflexhook :: KeyVal+xK_acircumflexhook = 0x1001ea9+xK_Acircumflextilde :: KeyVal+xK_Acircumflextilde = 0x1001eaa+xK_acircumflextilde :: KeyVal+xK_acircumflextilde = 0x1001eab+xK_Acircumflexbelowdot :: KeyVal+xK_Acircumflexbelowdot = 0x1001eac+xK_acircumflexbelowdot :: KeyVal+xK_acircumflexbelowdot = 0x1001ead+xK_Abreveacute :: KeyVal+xK_Abreveacute = 0x1001eae+xK_abreveacute :: KeyVal+xK_abreveacute = 0x1001eaf+xK_Abrevegrave :: KeyVal+xK_Abrevegrave = 0x1001eb0+xK_abrevegrave :: KeyVal+xK_abrevegrave = 0x1001eb1+xK_Abrevehook :: KeyVal+xK_Abrevehook = 0x1001eb2+xK_abrevehook :: KeyVal+xK_abrevehook = 0x1001eb3+xK_Abrevetilde :: KeyVal+xK_Abrevetilde = 0x1001eb4+xK_abrevetilde :: KeyVal+xK_abrevetilde = 0x1001eb5+xK_Abrevebelowdot :: KeyVal+xK_Abrevebelowdot = 0x1001eb6+xK_abrevebelowdot :: KeyVal+xK_abrevebelowdot = 0x1001eb7+xK_Ebelowdot :: KeyVal+xK_Ebelowdot = 0x1001eb8+xK_ebelowdot :: KeyVal+xK_ebelowdot = 0x1001eb9+xK_Ehook :: KeyVal+xK_Ehook = 0x1001eba+xK_ehook :: KeyVal+xK_ehook = 0x1001ebb+xK_Etilde :: KeyVal+xK_Etilde = 0x1001ebc+xK_etilde :: KeyVal+xK_etilde = 0x1001ebd+xK_Ecircumflexacute :: KeyVal+xK_Ecircumflexacute = 0x1001ebe+xK_ecircumflexacute :: KeyVal+xK_ecircumflexacute = 0x1001ebf+xK_Ecircumflexgrave :: KeyVal+xK_Ecircumflexgrave = 0x1001ec0+xK_ecircumflexgrave :: KeyVal+xK_ecircumflexgrave = 0x1001ec1+xK_Ecircumflexhook :: KeyVal+xK_Ecircumflexhook = 0x1001ec2+xK_ecircumflexhook :: KeyVal+xK_ecircumflexhook = 0x1001ec3+xK_Ecircumflextilde :: KeyVal+xK_Ecircumflextilde = 0x1001ec4+xK_ecircumflextilde :: KeyVal+xK_ecircumflextilde = 0x1001ec5+xK_Ecircumflexbelowdot :: KeyVal+xK_Ecircumflexbelowdot = 0x1001ec6+xK_ecircumflexbelowdot :: KeyVal+xK_ecircumflexbelowdot = 0x1001ec7+xK_Ihook :: KeyVal+xK_Ihook = 0x1001ec8+xK_ihook :: KeyVal+xK_ihook = 0x1001ec9+xK_Ibelowdot :: KeyVal+xK_Ibelowdot = 0x1001eca+xK_ibelowdot :: KeyVal+xK_ibelowdot = 0x1001ecb+xK_Obelowdot :: KeyVal+xK_Obelowdot = 0x1001ecc+xK_obelowdot :: KeyVal+xK_obelowdot = 0x1001ecd+xK_Ohook :: KeyVal+xK_Ohook = 0x1001ece+xK_ohook :: KeyVal+xK_ohook = 0x1001ecf+xK_Ocircumflexacute :: KeyVal+xK_Ocircumflexacute = 0x1001ed0+xK_ocircumflexacute :: KeyVal+xK_ocircumflexacute = 0x1001ed1+xK_Ocircumflexgrave :: KeyVal+xK_Ocircumflexgrave = 0x1001ed2+xK_ocircumflexgrave :: KeyVal+xK_ocircumflexgrave = 0x1001ed3+xK_Ocircumflexhook :: KeyVal+xK_Ocircumflexhook = 0x1001ed4+xK_ocircumflexhook :: KeyVal+xK_ocircumflexhook = 0x1001ed5+xK_Ocircumflextilde :: KeyVal+xK_Ocircumflextilde = 0x1001ed6+xK_ocircumflextilde :: KeyVal+xK_ocircumflextilde = 0x1001ed7+xK_Ocircumflexbelowdot :: KeyVal+xK_Ocircumflexbelowdot = 0x1001ed8+xK_ocircumflexbelowdot :: KeyVal+xK_ocircumflexbelowdot = 0x1001ed9+xK_Ohornacute :: KeyVal+xK_Ohornacute = 0x1001eda+xK_ohornacute :: KeyVal+xK_ohornacute = 0x1001edb+xK_Ohorngrave :: KeyVal+xK_Ohorngrave = 0x1001edc+xK_ohorngrave :: KeyVal+xK_ohorngrave = 0x1001edd+xK_Ohornhook :: KeyVal+xK_Ohornhook = 0x1001ede+xK_ohornhook :: KeyVal+xK_ohornhook = 0x1001edf+xK_Ohorntilde :: KeyVal+xK_Ohorntilde = 0x1001ee0+xK_ohorntilde :: KeyVal+xK_ohorntilde = 0x1001ee1+xK_Ohornbelowdot :: KeyVal+xK_Ohornbelowdot = 0x1001ee2+xK_ohornbelowdot :: KeyVal+xK_ohornbelowdot = 0x1001ee3+xK_Ubelowdot :: KeyVal+xK_Ubelowdot = 0x1001ee4+xK_ubelowdot :: KeyVal+xK_ubelowdot = 0x1001ee5+xK_Uhook :: KeyVal+xK_Uhook = 0x1001ee6+xK_uhook :: KeyVal+xK_uhook = 0x1001ee7+xK_Uhornacute :: KeyVal+xK_Uhornacute = 0x1001ee8+xK_uhornacute :: KeyVal+xK_uhornacute = 0x1001ee9+xK_Uhorngrave :: KeyVal+xK_Uhorngrave = 0x1001eea+xK_uhorngrave :: KeyVal+xK_uhorngrave = 0x1001eeb+xK_Uhornhook :: KeyVal+xK_Uhornhook = 0x1001eec+xK_uhornhook :: KeyVal+xK_uhornhook = 0x1001eed+xK_Uhorntilde :: KeyVal+xK_Uhorntilde = 0x1001eee+xK_uhorntilde :: KeyVal+xK_uhorntilde = 0x1001eef+xK_Uhornbelowdot :: KeyVal+xK_Uhornbelowdot = 0x1001ef0+xK_uhornbelowdot :: KeyVal+xK_uhornbelowdot = 0x1001ef1+xK_Ybelowdot :: KeyVal+xK_Ybelowdot = 0x1001ef4+xK_ybelowdot :: KeyVal+xK_ybelowdot = 0x1001ef5+xK_Yhook :: KeyVal+xK_Yhook = 0x1001ef6+xK_yhook :: KeyVal+xK_yhook = 0x1001ef7+xK_Ytilde :: KeyVal+xK_Ytilde = 0x1001ef8+xK_ytilde :: KeyVal+xK_ytilde = 0x1001ef9+xK_Ohorn :: KeyVal+xK_Ohorn = 0x10001a0+xK_ohorn :: KeyVal+xK_ohorn = 0x10001a1+xK_Uhorn :: KeyVal+xK_Uhorn = 0x10001af+xK_uhorn :: KeyVal+xK_uhorn = 0x10001b0+xK_EcuSign :: KeyVal+xK_EcuSign = 0x10020a0+xK_ColonSign :: KeyVal+xK_ColonSign = 0x10020a1+xK_CruzeiroSign :: KeyVal+xK_CruzeiroSign = 0x10020a2+xK_FFrancSign :: KeyVal+xK_FFrancSign = 0x10020a3+xK_LiraSign :: KeyVal+xK_LiraSign = 0x10020a4+xK_MillSign :: KeyVal+xK_MillSign = 0x10020a5+xK_NairaSign :: KeyVal+xK_NairaSign = 0x10020a6+xK_PesetaSign :: KeyVal+xK_PesetaSign = 0x10020a7+xK_RupeeSign :: KeyVal+xK_RupeeSign = 0x10020a8+xK_WonSign :: KeyVal+xK_WonSign = 0x10020a9+xK_NewSheqelSign :: KeyVal+xK_NewSheqelSign = 0x10020aa+xK_DongSign :: KeyVal+xK_DongSign = 0x10020ab+xK_EuroSign :: KeyVal+xK_EuroSign = 0x20ac+xK_zerosuperior :: KeyVal+xK_zerosuperior = 0x1002070+xK_foursuperior :: KeyVal+xK_foursuperior = 0x1002074+xK_fivesuperior :: KeyVal+xK_fivesuperior = 0x1002075+xK_sixsuperior :: KeyVal+xK_sixsuperior = 0x1002076+xK_sevensuperior :: KeyVal+xK_sevensuperior = 0x1002077+xK_eightsuperior :: KeyVal+xK_eightsuperior = 0x1002078+xK_ninesuperior :: KeyVal+xK_ninesuperior = 0x1002079+xK_zerosubscript :: KeyVal+xK_zerosubscript = 0x1002080+xK_onesubscript :: KeyVal+xK_onesubscript = 0x1002081+xK_twosubscript :: KeyVal+xK_twosubscript = 0x1002082+xK_threesubscript :: KeyVal+xK_threesubscript = 0x1002083+xK_foursubscript :: KeyVal+xK_foursubscript = 0x1002084+xK_fivesubscript :: KeyVal+xK_fivesubscript = 0x1002085+xK_sixsubscript :: KeyVal+xK_sixsubscript = 0x1002086+xK_sevensubscript :: KeyVal+xK_sevensubscript = 0x1002087+xK_eightsubscript :: KeyVal+xK_eightsubscript = 0x1002088+xK_ninesubscript :: KeyVal+xK_ninesubscript = 0x1002089+xK_partdifferential :: KeyVal+xK_partdifferential = 0x1002202+xK_emptyset :: KeyVal+xK_emptyset = 0x1002205+xK_elementof :: KeyVal+xK_elementof = 0x1002208+xK_notelementof :: KeyVal+xK_notelementof = 0x1002209+xK_containsas :: KeyVal+xK_containsas = 0x100220b+xK_squareroot :: KeyVal+xK_squareroot = 0x100221a+xK_cuberoot :: KeyVal+xK_cuberoot = 0x100221b+xK_fourthroot :: KeyVal+xK_fourthroot = 0x100221c+xK_dintegral :: KeyVal+xK_dintegral = 0x100222c+xK_tintegral :: KeyVal+xK_tintegral = 0x100222d+xK_because :: KeyVal+xK_because = 0x1002235+xK_approxeq :: KeyVal+xK_approxeq = 0x1002248+xK_notapproxeq :: KeyVal+xK_notapproxeq = 0x1002247+xK_notidentical :: KeyVal+xK_notidentical = 0x1002262+xK_stricteq :: KeyVal+xK_stricteq = 0x1002263+xK_braille_dot_1 :: KeyVal+xK_braille_dot_1 = 0xfff1+xK_braille_dot_2 :: KeyVal+xK_braille_dot_2 = 0xfff2+xK_braille_dot_3 :: KeyVal+xK_braille_dot_3 = 0xfff3+xK_braille_dot_4 :: KeyVal+xK_braille_dot_4 = 0xfff4+xK_braille_dot_5 :: KeyVal+xK_braille_dot_5 = 0xfff5+xK_braille_dot_6 :: KeyVal+xK_braille_dot_6 = 0xfff6+xK_braille_dot_7 :: KeyVal+xK_braille_dot_7 = 0xfff7+xK_braille_dot_8 :: KeyVal+xK_braille_dot_8 = 0xfff8+xK_braille_dot_9 :: KeyVal+xK_braille_dot_9 = 0xfff9+xK_braille_dot_10 :: KeyVal+xK_braille_dot_10 = 0xfffa+xK_braille_blank :: KeyVal+xK_braille_blank = 0x1002800+xK_braille_dots_1 :: KeyVal+xK_braille_dots_1 = 0x1002801+xK_braille_dots_2 :: KeyVal+xK_braille_dots_2 = 0x1002802+xK_braille_dots_12 :: KeyVal+xK_braille_dots_12 = 0x1002803+xK_braille_dots_3 :: KeyVal+xK_braille_dots_3 = 0x1002804+xK_braille_dots_13 :: KeyVal+xK_braille_dots_13 = 0x1002805+xK_braille_dots_23 :: KeyVal+xK_braille_dots_23 = 0x1002806+xK_braille_dots_123 :: KeyVal+xK_braille_dots_123 = 0x1002807+xK_braille_dots_4 :: KeyVal+xK_braille_dots_4 = 0x1002808+xK_braille_dots_14 :: KeyVal+xK_braille_dots_14 = 0x1002809+xK_braille_dots_24 :: KeyVal+xK_braille_dots_24 = 0x100280a+xK_braille_dots_124 :: KeyVal+xK_braille_dots_124 = 0x100280b+xK_braille_dots_34 :: KeyVal+xK_braille_dots_34 = 0x100280c+xK_braille_dots_134 :: KeyVal+xK_braille_dots_134 = 0x100280d+xK_braille_dots_234 :: KeyVal+xK_braille_dots_234 = 0x100280e+xK_braille_dots_1234 :: KeyVal+xK_braille_dots_1234 = 0x100280f+xK_braille_dots_5 :: KeyVal+xK_braille_dots_5 = 0x1002810+xK_braille_dots_15 :: KeyVal+xK_braille_dots_15 = 0x1002811+xK_braille_dots_25 :: KeyVal+xK_braille_dots_25 = 0x1002812+xK_braille_dots_125 :: KeyVal+xK_braille_dots_125 = 0x1002813+xK_braille_dots_35 :: KeyVal+xK_braille_dots_35 = 0x1002814+xK_braille_dots_135 :: KeyVal+xK_braille_dots_135 = 0x1002815+xK_braille_dots_235 :: KeyVal+xK_braille_dots_235 = 0x1002816+xK_braille_dots_1235 :: KeyVal+xK_braille_dots_1235 = 0x1002817+xK_braille_dots_45 :: KeyVal+xK_braille_dots_45 = 0x1002818+xK_braille_dots_145 :: KeyVal+xK_braille_dots_145 = 0x1002819+xK_braille_dots_245 :: KeyVal+xK_braille_dots_245 = 0x100281a+xK_braille_dots_1245 :: KeyVal+xK_braille_dots_1245 = 0x100281b+xK_braille_dots_345 :: KeyVal+xK_braille_dots_345 = 0x100281c+xK_braille_dots_1345 :: KeyVal+xK_braille_dots_1345 = 0x100281d+xK_braille_dots_2345 :: KeyVal+xK_braille_dots_2345 = 0x100281e+xK_braille_dots_12345 :: KeyVal+xK_braille_dots_12345 = 0x100281f+xK_braille_dots_6 :: KeyVal+xK_braille_dots_6 = 0x1002820+xK_braille_dots_16 :: KeyVal+xK_braille_dots_16 = 0x1002821+xK_braille_dots_26 :: KeyVal+xK_braille_dots_26 = 0x1002822+xK_braille_dots_126 :: KeyVal+xK_braille_dots_126 = 0x1002823+xK_braille_dots_36 :: KeyVal+xK_braille_dots_36 = 0x1002824+xK_braille_dots_136 :: KeyVal+xK_braille_dots_136 = 0x1002825+xK_braille_dots_236 :: KeyVal+xK_braille_dots_236 = 0x1002826+xK_braille_dots_1236 :: KeyVal+xK_braille_dots_1236 = 0x1002827+xK_braille_dots_46 :: KeyVal+xK_braille_dots_46 = 0x1002828+xK_braille_dots_146 :: KeyVal+xK_braille_dots_146 = 0x1002829+xK_braille_dots_246 :: KeyVal+xK_braille_dots_246 = 0x100282a+xK_braille_dots_1246 :: KeyVal+xK_braille_dots_1246 = 0x100282b+xK_braille_dots_346 :: KeyVal+xK_braille_dots_346 = 0x100282c+xK_braille_dots_1346 :: KeyVal+xK_braille_dots_1346 = 0x100282d+xK_braille_dots_2346 :: KeyVal+xK_braille_dots_2346 = 0x100282e+xK_braille_dots_12346 :: KeyVal+xK_braille_dots_12346 = 0x100282f+xK_braille_dots_56 :: KeyVal+xK_braille_dots_56 = 0x1002830+xK_braille_dots_156 :: KeyVal+xK_braille_dots_156 = 0x1002831+xK_braille_dots_256 :: KeyVal+xK_braille_dots_256 = 0x1002832+xK_braille_dots_1256 :: KeyVal+xK_braille_dots_1256 = 0x1002833+xK_braille_dots_356 :: KeyVal+xK_braille_dots_356 = 0x1002834+xK_braille_dots_1356 :: KeyVal+xK_braille_dots_1356 = 0x1002835+xK_braille_dots_2356 :: KeyVal+xK_braille_dots_2356 = 0x1002836+xK_braille_dots_12356 :: KeyVal+xK_braille_dots_12356 = 0x1002837+xK_braille_dots_456 :: KeyVal+xK_braille_dots_456 = 0x1002838+xK_braille_dots_1456 :: KeyVal+xK_braille_dots_1456 = 0x1002839+xK_braille_dots_2456 :: KeyVal+xK_braille_dots_2456 = 0x100283a+xK_braille_dots_12456 :: KeyVal+xK_braille_dots_12456 = 0x100283b+xK_braille_dots_3456 :: KeyVal+xK_braille_dots_3456 = 0x100283c+xK_braille_dots_13456 :: KeyVal+xK_braille_dots_13456 = 0x100283d+xK_braille_dots_23456 :: KeyVal+xK_braille_dots_23456 = 0x100283e+xK_braille_dots_123456 :: KeyVal+xK_braille_dots_123456 = 0x100283f+xK_braille_dots_7 :: KeyVal+xK_braille_dots_7 = 0x1002840+xK_braille_dots_17 :: KeyVal+xK_braille_dots_17 = 0x1002841+xK_braille_dots_27 :: KeyVal+xK_braille_dots_27 = 0x1002842+xK_braille_dots_127 :: KeyVal+xK_braille_dots_127 = 0x1002843+xK_braille_dots_37 :: KeyVal+xK_braille_dots_37 = 0x1002844+xK_braille_dots_137 :: KeyVal+xK_braille_dots_137 = 0x1002845+xK_braille_dots_237 :: KeyVal+xK_braille_dots_237 = 0x1002846+xK_braille_dots_1237 :: KeyVal+xK_braille_dots_1237 = 0x1002847+xK_braille_dots_47 :: KeyVal+xK_braille_dots_47 = 0x1002848+xK_braille_dots_147 :: KeyVal+xK_braille_dots_147 = 0x1002849+xK_braille_dots_247 :: KeyVal+xK_braille_dots_247 = 0x100284a+xK_braille_dots_1247 :: KeyVal+xK_braille_dots_1247 = 0x100284b+xK_braille_dots_347 :: KeyVal+xK_braille_dots_347 = 0x100284c+xK_braille_dots_1347 :: KeyVal+xK_braille_dots_1347 = 0x100284d+xK_braille_dots_2347 :: KeyVal+xK_braille_dots_2347 = 0x100284e+xK_braille_dots_12347 :: KeyVal+xK_braille_dots_12347 = 0x100284f+xK_braille_dots_57 :: KeyVal+xK_braille_dots_57 = 0x1002850+xK_braille_dots_157 :: KeyVal+xK_braille_dots_157 = 0x1002851+xK_braille_dots_257 :: KeyVal+xK_braille_dots_257 = 0x1002852+xK_braille_dots_1257 :: KeyVal+xK_braille_dots_1257 = 0x1002853+xK_braille_dots_357 :: KeyVal+xK_braille_dots_357 = 0x1002854+xK_braille_dots_1357 :: KeyVal+xK_braille_dots_1357 = 0x1002855+xK_braille_dots_2357 :: KeyVal+xK_braille_dots_2357 = 0x1002856+xK_braille_dots_12357 :: KeyVal+xK_braille_dots_12357 = 0x1002857+xK_braille_dots_457 :: KeyVal+xK_braille_dots_457 = 0x1002858+xK_braille_dots_1457 :: KeyVal+xK_braille_dots_1457 = 0x1002859+xK_braille_dots_2457 :: KeyVal+xK_braille_dots_2457 = 0x100285a+xK_braille_dots_12457 :: KeyVal+xK_braille_dots_12457 = 0x100285b+xK_braille_dots_3457 :: KeyVal+xK_braille_dots_3457 = 0x100285c+xK_braille_dots_13457 :: KeyVal+xK_braille_dots_13457 = 0x100285d+xK_braille_dots_23457 :: KeyVal+xK_braille_dots_23457 = 0x100285e+xK_braille_dots_123457 :: KeyVal+xK_braille_dots_123457 = 0x100285f+xK_braille_dots_67 :: KeyVal+xK_braille_dots_67 = 0x1002860+xK_braille_dots_167 :: KeyVal+xK_braille_dots_167 = 0x1002861+xK_braille_dots_267 :: KeyVal+xK_braille_dots_267 = 0x1002862+xK_braille_dots_1267 :: KeyVal+xK_braille_dots_1267 = 0x1002863+xK_braille_dots_367 :: KeyVal+xK_braille_dots_367 = 0x1002864+xK_braille_dots_1367 :: KeyVal+xK_braille_dots_1367 = 0x1002865+xK_braille_dots_2367 :: KeyVal+xK_braille_dots_2367 = 0x1002866+xK_braille_dots_12367 :: KeyVal+xK_braille_dots_12367 = 0x1002867+xK_braille_dots_467 :: KeyVal+xK_braille_dots_467 = 0x1002868+xK_braille_dots_1467 :: KeyVal+xK_braille_dots_1467 = 0x1002869+xK_braille_dots_2467 :: KeyVal+xK_braille_dots_2467 = 0x100286a+xK_braille_dots_12467 :: KeyVal+xK_braille_dots_12467 = 0x100286b+xK_braille_dots_3467 :: KeyVal+xK_braille_dots_3467 = 0x100286c+xK_braille_dots_13467 :: KeyVal+xK_braille_dots_13467 = 0x100286d+xK_braille_dots_23467 :: KeyVal+xK_braille_dots_23467 = 0x100286e+xK_braille_dots_123467 :: KeyVal+xK_braille_dots_123467 = 0x100286f+xK_braille_dots_567 :: KeyVal+xK_braille_dots_567 = 0x1002870+xK_braille_dots_1567 :: KeyVal+xK_braille_dots_1567 = 0x1002871+xK_braille_dots_2567 :: KeyVal+xK_braille_dots_2567 = 0x1002872+xK_braille_dots_12567 :: KeyVal+xK_braille_dots_12567 = 0x1002873+xK_braille_dots_3567 :: KeyVal+xK_braille_dots_3567 = 0x1002874+xK_braille_dots_13567 :: KeyVal+xK_braille_dots_13567 = 0x1002875+xK_braille_dots_23567 :: KeyVal+xK_braille_dots_23567 = 0x1002876+xK_braille_dots_123567 :: KeyVal+xK_braille_dots_123567 = 0x1002877+xK_braille_dots_4567 :: KeyVal+xK_braille_dots_4567 = 0x1002878+xK_braille_dots_14567 :: KeyVal+xK_braille_dots_14567 = 0x1002879+xK_braille_dots_24567 :: KeyVal+xK_braille_dots_24567 = 0x100287a+xK_braille_dots_124567 :: KeyVal+xK_braille_dots_124567 = 0x100287b+xK_braille_dots_34567 :: KeyVal+xK_braille_dots_34567 = 0x100287c+xK_braille_dots_134567 :: KeyVal+xK_braille_dots_134567 = 0x100287d+xK_braille_dots_234567 :: KeyVal+xK_braille_dots_234567 = 0x100287e+xK_braille_dots_1234567 :: KeyVal+xK_braille_dots_1234567 = 0x100287f+xK_braille_dots_8 :: KeyVal+xK_braille_dots_8 = 0x1002880+xK_braille_dots_18 :: KeyVal+xK_braille_dots_18 = 0x1002881+xK_braille_dots_28 :: KeyVal+xK_braille_dots_28 = 0x1002882+xK_braille_dots_128 :: KeyVal+xK_braille_dots_128 = 0x1002883+xK_braille_dots_38 :: KeyVal+xK_braille_dots_38 = 0x1002884+xK_braille_dots_138 :: KeyVal+xK_braille_dots_138 = 0x1002885+xK_braille_dots_238 :: KeyVal+xK_braille_dots_238 = 0x1002886+xK_braille_dots_1238 :: KeyVal+xK_braille_dots_1238 = 0x1002887+xK_braille_dots_48 :: KeyVal+xK_braille_dots_48 = 0x1002888+xK_braille_dots_148 :: KeyVal+xK_braille_dots_148 = 0x1002889+xK_braille_dots_248 :: KeyVal+xK_braille_dots_248 = 0x100288a+xK_braille_dots_1248 :: KeyVal+xK_braille_dots_1248 = 0x100288b+xK_braille_dots_348 :: KeyVal+xK_braille_dots_348 = 0x100288c+xK_braille_dots_1348 :: KeyVal+xK_braille_dots_1348 = 0x100288d+xK_braille_dots_2348 :: KeyVal+xK_braille_dots_2348 = 0x100288e+xK_braille_dots_12348 :: KeyVal+xK_braille_dots_12348 = 0x100288f+xK_braille_dots_58 :: KeyVal+xK_braille_dots_58 = 0x1002890+xK_braille_dots_158 :: KeyVal+xK_braille_dots_158 = 0x1002891+xK_braille_dots_258 :: KeyVal+xK_braille_dots_258 = 0x1002892+xK_braille_dots_1258 :: KeyVal+xK_braille_dots_1258 = 0x1002893+xK_braille_dots_358 :: KeyVal+xK_braille_dots_358 = 0x1002894+xK_braille_dots_1358 :: KeyVal+xK_braille_dots_1358 = 0x1002895+xK_braille_dots_2358 :: KeyVal+xK_braille_dots_2358 = 0x1002896+xK_braille_dots_12358 :: KeyVal+xK_braille_dots_12358 = 0x1002897+xK_braille_dots_458 :: KeyVal+xK_braille_dots_458 = 0x1002898+xK_braille_dots_1458 :: KeyVal+xK_braille_dots_1458 = 0x1002899+xK_braille_dots_2458 :: KeyVal+xK_braille_dots_2458 = 0x100289a+xK_braille_dots_12458 :: KeyVal+xK_braille_dots_12458 = 0x100289b+xK_braille_dots_3458 :: KeyVal+xK_braille_dots_3458 = 0x100289c+xK_braille_dots_13458 :: KeyVal+xK_braille_dots_13458 = 0x100289d+xK_braille_dots_23458 :: KeyVal+xK_braille_dots_23458 = 0x100289e+xK_braille_dots_123458 :: KeyVal+xK_braille_dots_123458 = 0x100289f+xK_braille_dots_68 :: KeyVal+xK_braille_dots_68 = 0x10028a0+xK_braille_dots_168 :: KeyVal+xK_braille_dots_168 = 0x10028a1+xK_braille_dots_268 :: KeyVal+xK_braille_dots_268 = 0x10028a2+xK_braille_dots_1268 :: KeyVal+xK_braille_dots_1268 = 0x10028a3+xK_braille_dots_368 :: KeyVal+xK_braille_dots_368 = 0x10028a4+xK_braille_dots_1368 :: KeyVal+xK_braille_dots_1368 = 0x10028a5+xK_braille_dots_2368 :: KeyVal+xK_braille_dots_2368 = 0x10028a6+xK_braille_dots_12368 :: KeyVal+xK_braille_dots_12368 = 0x10028a7+xK_braille_dots_468 :: KeyVal+xK_braille_dots_468 = 0x10028a8+xK_braille_dots_1468 :: KeyVal+xK_braille_dots_1468 = 0x10028a9+xK_braille_dots_2468 :: KeyVal+xK_braille_dots_2468 = 0x10028aa+xK_braille_dots_12468 :: KeyVal+xK_braille_dots_12468 = 0x10028ab+xK_braille_dots_3468 :: KeyVal+xK_braille_dots_3468 = 0x10028ac+xK_braille_dots_13468 :: KeyVal+xK_braille_dots_13468 = 0x10028ad+xK_braille_dots_23468 :: KeyVal+xK_braille_dots_23468 = 0x10028ae+xK_braille_dots_123468 :: KeyVal+xK_braille_dots_123468 = 0x10028af+xK_braille_dots_568 :: KeyVal+xK_braille_dots_568 = 0x10028b0+xK_braille_dots_1568 :: KeyVal+xK_braille_dots_1568 = 0x10028b1+xK_braille_dots_2568 :: KeyVal+xK_braille_dots_2568 = 0x10028b2+xK_braille_dots_12568 :: KeyVal+xK_braille_dots_12568 = 0x10028b3+xK_braille_dots_3568 :: KeyVal+xK_braille_dots_3568 = 0x10028b4+xK_braille_dots_13568 :: KeyVal+xK_braille_dots_13568 = 0x10028b5+xK_braille_dots_23568 :: KeyVal+xK_braille_dots_23568 = 0x10028b6+xK_braille_dots_123568 :: KeyVal+xK_braille_dots_123568 = 0x10028b7+xK_braille_dots_4568 :: KeyVal+xK_braille_dots_4568 = 0x10028b8+xK_braille_dots_14568 :: KeyVal+xK_braille_dots_14568 = 0x10028b9+xK_braille_dots_24568 :: KeyVal+xK_braille_dots_24568 = 0x10028ba+xK_braille_dots_124568 :: KeyVal+xK_braille_dots_124568 = 0x10028bb+xK_braille_dots_34568 :: KeyVal+xK_braille_dots_34568 = 0x10028bc+xK_braille_dots_134568 :: KeyVal+xK_braille_dots_134568 = 0x10028bd+xK_braille_dots_234568 :: KeyVal+xK_braille_dots_234568 = 0x10028be+xK_braille_dots_1234568 :: KeyVal+xK_braille_dots_1234568 = 0x10028bf+xK_braille_dots_78 :: KeyVal+xK_braille_dots_78 = 0x10028c0+xK_braille_dots_178 :: KeyVal+xK_braille_dots_178 = 0x10028c1+xK_braille_dots_278 :: KeyVal+xK_braille_dots_278 = 0x10028c2+xK_braille_dots_1278 :: KeyVal+xK_braille_dots_1278 = 0x10028c3+xK_braille_dots_378 :: KeyVal+xK_braille_dots_378 = 0x10028c4+xK_braille_dots_1378 :: KeyVal+xK_braille_dots_1378 = 0x10028c5+xK_braille_dots_2378 :: KeyVal+xK_braille_dots_2378 = 0x10028c6+xK_braille_dots_12378 :: KeyVal+xK_braille_dots_12378 = 0x10028c7+xK_braille_dots_478 :: KeyVal+xK_braille_dots_478 = 0x10028c8+xK_braille_dots_1478 :: KeyVal+xK_braille_dots_1478 = 0x10028c9+xK_braille_dots_2478 :: KeyVal+xK_braille_dots_2478 = 0x10028ca+xK_braille_dots_12478 :: KeyVal+xK_braille_dots_12478 = 0x10028cb+xK_braille_dots_3478 :: KeyVal+xK_braille_dots_3478 = 0x10028cc+xK_braille_dots_13478 :: KeyVal+xK_braille_dots_13478 = 0x10028cd+xK_braille_dots_23478 :: KeyVal+xK_braille_dots_23478 = 0x10028ce+xK_braille_dots_123478 :: KeyVal+xK_braille_dots_123478 = 0x10028cf+xK_braille_dots_578 :: KeyVal+xK_braille_dots_578 = 0x10028d0+xK_braille_dots_1578 :: KeyVal+xK_braille_dots_1578 = 0x10028d1+xK_braille_dots_2578 :: KeyVal+xK_braille_dots_2578 = 0x10028d2+xK_braille_dots_12578 :: KeyVal+xK_braille_dots_12578 = 0x10028d3+xK_braille_dots_3578 :: KeyVal+xK_braille_dots_3578 = 0x10028d4+xK_braille_dots_13578 :: KeyVal+xK_braille_dots_13578 = 0x10028d5+xK_braille_dots_23578 :: KeyVal+xK_braille_dots_23578 = 0x10028d6+xK_braille_dots_123578 :: KeyVal+xK_braille_dots_123578 = 0x10028d7+xK_braille_dots_4578 :: KeyVal+xK_braille_dots_4578 = 0x10028d8+xK_braille_dots_14578 :: KeyVal+xK_braille_dots_14578 = 0x10028d9+xK_braille_dots_24578 :: KeyVal+xK_braille_dots_24578 = 0x10028da+xK_braille_dots_124578 :: KeyVal+xK_braille_dots_124578 = 0x10028db+xK_braille_dots_34578 :: KeyVal+xK_braille_dots_34578 = 0x10028dc+xK_braille_dots_134578 :: KeyVal+xK_braille_dots_134578 = 0x10028dd+xK_braille_dots_234578 :: KeyVal+xK_braille_dots_234578 = 0x10028de+xK_braille_dots_1234578 :: KeyVal+xK_braille_dots_1234578 = 0x10028df+xK_braille_dots_678 :: KeyVal+xK_braille_dots_678 = 0x10028e0+xK_braille_dots_1678 :: KeyVal+xK_braille_dots_1678 = 0x10028e1+xK_braille_dots_2678 :: KeyVal+xK_braille_dots_2678 = 0x10028e2+xK_braille_dots_12678 :: KeyVal+xK_braille_dots_12678 = 0x10028e3+xK_braille_dots_3678 :: KeyVal+xK_braille_dots_3678 = 0x10028e4+xK_braille_dots_13678 :: KeyVal+xK_braille_dots_13678 = 0x10028e5+xK_braille_dots_23678 :: KeyVal+xK_braille_dots_23678 = 0x10028e6+xK_braille_dots_123678 :: KeyVal+xK_braille_dots_123678 = 0x10028e7+xK_braille_dots_4678 :: KeyVal+xK_braille_dots_4678 = 0x10028e8+xK_braille_dots_14678 :: KeyVal+xK_braille_dots_14678 = 0x10028e9+xK_braille_dots_24678 :: KeyVal+xK_braille_dots_24678 = 0x10028ea+xK_braille_dots_124678 :: KeyVal+xK_braille_dots_124678 = 0x10028eb+xK_braille_dots_34678 :: KeyVal+xK_braille_dots_34678 = 0x10028ec+xK_braille_dots_134678 :: KeyVal+xK_braille_dots_134678 = 0x10028ed+xK_braille_dots_234678 :: KeyVal+xK_braille_dots_234678 = 0x10028ee+xK_braille_dots_1234678 :: KeyVal+xK_braille_dots_1234678 = 0x10028ef+xK_braille_dots_5678 :: KeyVal+xK_braille_dots_5678 = 0x10028f0+xK_braille_dots_15678 :: KeyVal+xK_braille_dots_15678 = 0x10028f1+xK_braille_dots_25678 :: KeyVal+xK_braille_dots_25678 = 0x10028f2+xK_braille_dots_125678 :: KeyVal+xK_braille_dots_125678 = 0x10028f3+xK_braille_dots_35678 :: KeyVal+xK_braille_dots_35678 = 0x10028f4+xK_braille_dots_135678 :: KeyVal+xK_braille_dots_135678 = 0x10028f5+xK_braille_dots_235678 :: KeyVal+xK_braille_dots_235678 = 0x10028f6+xK_braille_dots_1235678 :: KeyVal+xK_braille_dots_1235678 = 0x10028f7+xK_braille_dots_45678 :: KeyVal+xK_braille_dots_45678 = 0x10028f8+xK_braille_dots_145678 :: KeyVal+xK_braille_dots_145678 = 0x10028f9+xK_braille_dots_245678 :: KeyVal+xK_braille_dots_245678 = 0x10028fa+xK_braille_dots_1245678 :: KeyVal+xK_braille_dots_1245678 = 0x10028fb+xK_braille_dots_345678 :: KeyVal+xK_braille_dots_345678 = 0x10028fc+xK_braille_dots_1345678 :: KeyVal+xK_braille_dots_1345678 = 0x10028fd+xK_braille_dots_2345678 :: KeyVal+xK_braille_dots_2345678 = 0x10028fe+xK_braille_dots_12345678 :: KeyVal+xK_braille_dots_12345678 = 0x10028ff+xK_Sinh_ng :: KeyVal+xK_Sinh_ng = 0x1000d82+xK_Sinh_h2 :: KeyVal+xK_Sinh_h2 = 0x1000d83+xK_Sinh_a :: KeyVal+xK_Sinh_a = 0x1000d85+xK_Sinh_aa :: KeyVal+xK_Sinh_aa = 0x1000d86+xK_Sinh_ae :: KeyVal+xK_Sinh_ae = 0x1000d87+xK_Sinh_aee :: KeyVal+xK_Sinh_aee = 0x1000d88+xK_Sinh_i :: KeyVal+xK_Sinh_i = 0x1000d89+xK_Sinh_ii :: KeyVal+xK_Sinh_ii = 0x1000d8a+xK_Sinh_u :: KeyVal+xK_Sinh_u = 0x1000d8b+xK_Sinh_uu :: KeyVal+xK_Sinh_uu = 0x1000d8c+xK_Sinh_ri :: KeyVal+xK_Sinh_ri = 0x1000d8d+xK_Sinh_rii :: KeyVal+xK_Sinh_rii = 0x1000d8e+xK_Sinh_lu :: KeyVal+xK_Sinh_lu = 0x1000d8f+xK_Sinh_luu :: KeyVal+xK_Sinh_luu = 0x1000d90+xK_Sinh_e :: KeyVal+xK_Sinh_e = 0x1000d91+xK_Sinh_ee :: KeyVal+xK_Sinh_ee = 0x1000d92+xK_Sinh_ai :: KeyVal+xK_Sinh_ai = 0x1000d93+xK_Sinh_o :: KeyVal+xK_Sinh_o = 0x1000d94+xK_Sinh_oo :: KeyVal+xK_Sinh_oo = 0x1000d95+xK_Sinh_au :: KeyVal+xK_Sinh_au = 0x1000d96+xK_Sinh_ka :: KeyVal+xK_Sinh_ka = 0x1000d9a+xK_Sinh_kha :: KeyVal+xK_Sinh_kha = 0x1000d9b+xK_Sinh_ga :: KeyVal+xK_Sinh_ga = 0x1000d9c+xK_Sinh_gha :: KeyVal+xK_Sinh_gha = 0x1000d9d+xK_Sinh_ng2 :: KeyVal+xK_Sinh_ng2 = 0x1000d9e+xK_Sinh_nga :: KeyVal+xK_Sinh_nga = 0x1000d9f+xK_Sinh_ca :: KeyVal+xK_Sinh_ca = 0x1000da0+xK_Sinh_cha :: KeyVal+xK_Sinh_cha = 0x1000da1+xK_Sinh_ja :: KeyVal+xK_Sinh_ja = 0x1000da2+xK_Sinh_jha :: KeyVal+xK_Sinh_jha = 0x1000da3+xK_Sinh_nya :: KeyVal+xK_Sinh_nya = 0x1000da4+xK_Sinh_jnya :: KeyVal+xK_Sinh_jnya = 0x1000da5+xK_Sinh_nja :: KeyVal+xK_Sinh_nja = 0x1000da6+xK_Sinh_tta :: KeyVal+xK_Sinh_tta = 0x1000da7+xK_Sinh_ttha :: KeyVal+xK_Sinh_ttha = 0x1000da8+xK_Sinh_dda :: KeyVal+xK_Sinh_dda = 0x1000da9+xK_Sinh_ddha :: KeyVal+xK_Sinh_ddha = 0x1000daa+xK_Sinh_nna :: KeyVal+xK_Sinh_nna = 0x1000dab+xK_Sinh_ndda :: KeyVal+xK_Sinh_ndda = 0x1000dac+xK_Sinh_tha :: KeyVal+xK_Sinh_tha = 0x1000dad+xK_Sinh_thha :: KeyVal+xK_Sinh_thha = 0x1000dae+xK_Sinh_dha :: KeyVal+xK_Sinh_dha = 0x1000daf+xK_Sinh_dhha :: KeyVal+xK_Sinh_dhha = 0x1000db0+xK_Sinh_na :: KeyVal+xK_Sinh_na = 0x1000db1+xK_Sinh_ndha :: KeyVal+xK_Sinh_ndha = 0x1000db3+xK_Sinh_pa :: KeyVal+xK_Sinh_pa = 0x1000db4+xK_Sinh_pha :: KeyVal+xK_Sinh_pha = 0x1000db5+xK_Sinh_ba :: KeyVal+xK_Sinh_ba = 0x1000db6+xK_Sinh_bha :: KeyVal+xK_Sinh_bha = 0x1000db7+xK_Sinh_ma :: KeyVal+xK_Sinh_ma = 0x1000db8+xK_Sinh_mba :: KeyVal+xK_Sinh_mba = 0x1000db9+xK_Sinh_ya :: KeyVal+xK_Sinh_ya = 0x1000dba+xK_Sinh_ra :: KeyVal+xK_Sinh_ra = 0x1000dbb+xK_Sinh_la :: KeyVal+xK_Sinh_la = 0x1000dbd+xK_Sinh_va :: KeyVal+xK_Sinh_va = 0x1000dc0+xK_Sinh_sha :: KeyVal+xK_Sinh_sha = 0x1000dc1+xK_Sinh_ssha :: KeyVal+xK_Sinh_ssha = 0x1000dc2+xK_Sinh_sa :: KeyVal+xK_Sinh_sa = 0x1000dc3+xK_Sinh_ha :: KeyVal+xK_Sinh_ha = 0x1000dc4+xK_Sinh_lla :: KeyVal+xK_Sinh_lla = 0x1000dc5+xK_Sinh_fa :: KeyVal+xK_Sinh_fa = 0x1000dc6+xK_Sinh_al :: KeyVal+xK_Sinh_al = 0x1000dca+xK_Sinh_aa2 :: KeyVal+xK_Sinh_aa2 = 0x1000dcf+xK_Sinh_ae2 :: KeyVal+xK_Sinh_ae2 = 0x1000dd0+xK_Sinh_aee2 :: KeyVal+xK_Sinh_aee2 = 0x1000dd1+xK_Sinh_i2 :: KeyVal+xK_Sinh_i2 = 0x1000dd2+xK_Sinh_ii2 :: KeyVal+xK_Sinh_ii2 = 0x1000dd3+xK_Sinh_u2 :: KeyVal+xK_Sinh_u2 = 0x1000dd4+xK_Sinh_uu2 :: KeyVal+xK_Sinh_uu2 = 0x1000dd6+xK_Sinh_ru2 :: KeyVal+xK_Sinh_ru2 = 0x1000dd8+xK_Sinh_e2 :: KeyVal+xK_Sinh_e2 = 0x1000dd9+xK_Sinh_ee2 :: KeyVal+xK_Sinh_ee2 = 0x1000dda+xK_Sinh_ai2 :: KeyVal+xK_Sinh_ai2 = 0x1000ddb+xK_Sinh_o2 :: KeyVal+xK_Sinh_o2 = 0x1000ddc+xK_Sinh_oo2 :: KeyVal+xK_Sinh_oo2 = 0x1000ddd+xK_Sinh_au2 :: KeyVal+xK_Sinh_au2 = 0x1000dde+xK_Sinh_lu2 :: KeyVal+xK_Sinh_lu2 = 0x1000ddf+xK_Sinh_ruu2 :: KeyVal+xK_Sinh_ruu2 = 0x1000df2+xK_Sinh_luu2 :: KeyVal+xK_Sinh_luu2 = 0x1000df3+xK_Sinh_kunddaliya :: KeyVal+xK_Sinh_kunddaliya = 0x1000df4+xK_ModeLock :: KeyVal+xK_ModeLock = 0x1008ff01+xK_MonBrightnessUp :: KeyVal+xK_MonBrightnessUp = 0x1008ff02+xK_MonBrightnessDown :: KeyVal+xK_MonBrightnessDown = 0x1008ff03+xK_KbdLightOnOff :: KeyVal+xK_KbdLightOnOff = 0x1008ff04+xK_KbdBrightnessUp :: KeyVal+xK_KbdBrightnessUp = 0x1008ff05+xK_KbdBrightnessDown :: KeyVal+xK_KbdBrightnessDown = 0x1008ff06+xK_Standby :: KeyVal+xK_Standby = 0x1008ff10+xK_AudioLowerVolume :: KeyVal+xK_AudioLowerVolume = 0x1008ff11+xK_AudioMute :: KeyVal+xK_AudioMute = 0x1008ff12+xK_AudioRaiseVolume :: KeyVal+xK_AudioRaiseVolume = 0x1008ff13+xK_AudioPlay :: KeyVal+xK_AudioPlay = 0x1008ff14+xK_AudioStop :: KeyVal+xK_AudioStop = 0x1008ff15+xK_AudioPrev :: KeyVal+xK_AudioPrev = 0x1008ff16+xK_AudioNext :: KeyVal+xK_AudioNext = 0x1008ff17+xK_HomePage :: KeyVal+xK_HomePage = 0x1008ff18+xK_Mail :: KeyVal+xK_Mail = 0x1008ff19+xK_Start :: KeyVal+xK_Start = 0x1008ff1a+xK_Search :: KeyVal+xK_Search = 0x1008ff1b+xK_AudioRecord :: KeyVal+xK_AudioRecord = 0x1008ff1c+xK_Calculator :: KeyVal+xK_Calculator = 0x1008ff1d+xK_Memo :: KeyVal+xK_Memo = 0x1008ff1e+xK_ToDoList :: KeyVal+xK_ToDoList = 0x1008ff1f+xK_Calendar :: KeyVal+xK_Calendar = 0x1008ff20+xK_PowerDown :: KeyVal+xK_PowerDown = 0x1008ff21+xK_ContrastAdjust :: KeyVal+xK_ContrastAdjust = 0x1008ff22+xK_RockerUp :: KeyVal+xK_RockerUp = 0x1008ff23+xK_RockerDown :: KeyVal+xK_RockerDown = 0x1008ff24+xK_RockerEnter :: KeyVal+xK_RockerEnter = 0x1008ff25+xK_Back :: KeyVal+xK_Back = 0x1008ff26+xK_Forward :: KeyVal+xK_Forward = 0x1008ff27+xK_Stop :: KeyVal+xK_Stop = 0x1008ff28+xK_Refresh :: KeyVal+xK_Refresh = 0x1008ff29+xK_PowerOff :: KeyVal+xK_PowerOff = 0x1008ff2a+xK_WakeUp :: KeyVal+xK_WakeUp = 0x1008ff2b+xK_Eject :: KeyVal+xK_Eject = 0x1008ff2c+xK_ScreenSaver :: KeyVal+xK_ScreenSaver = 0x1008ff2d+xK_WWW :: KeyVal+xK_WWW = 0x1008ff2e+xK_Sleep :: KeyVal+xK_Sleep = 0x1008ff2f+xK_Favorites :: KeyVal+xK_Favorites = 0x1008ff30+xK_AudioPause :: KeyVal+xK_AudioPause = 0x1008ff31+xK_AudioMedia :: KeyVal+xK_AudioMedia = 0x1008ff32+xK_MyComputer :: KeyVal+xK_MyComputer = 0x1008ff33+xK_VendorHome :: KeyVal+xK_VendorHome = 0x1008ff34+xK_LightBulb :: KeyVal+xK_LightBulb = 0x1008ff35+xK_Shop :: KeyVal+xK_Shop = 0x1008ff36+xK_History :: KeyVal+xK_History = 0x1008ff37+xK_OpenURL :: KeyVal+xK_OpenURL = 0x1008ff38+xK_AddFavorite :: KeyVal+xK_AddFavorite = 0x1008ff39+xK_HotLinks :: KeyVal+xK_HotLinks = 0x1008ff3a+xK_BrightnessAdjust :: KeyVal+xK_BrightnessAdjust = 0x1008ff3b+xK_Finance :: KeyVal+xK_Finance = 0x1008ff3c+xK_Community :: KeyVal+xK_Community = 0x1008ff3d+xK_AudioRewind :: KeyVal+xK_AudioRewind = 0x1008ff3e+xK_BackForward :: KeyVal+xK_BackForward = 0x1008ff3f+xK_Launch0 :: KeyVal+xK_Launch0 = 0x1008ff40+xK_Launch1 :: KeyVal+xK_Launch1 = 0x1008ff41+xK_Launch2 :: KeyVal+xK_Launch2 = 0x1008ff42+xK_Launch3 :: KeyVal+xK_Launch3 = 0x1008ff43+xK_Launch4 :: KeyVal+xK_Launch4 = 0x1008ff44+xK_Launch5 :: KeyVal+xK_Launch5 = 0x1008ff45+xK_Launch6 :: KeyVal+xK_Launch6 = 0x1008ff46+xK_Launch7 :: KeyVal+xK_Launch7 = 0x1008ff47+xK_Launch8 :: KeyVal+xK_Launch8 = 0x1008ff48+xK_Launch9 :: KeyVal+xK_Launch9 = 0x1008ff49+xK_LaunchA :: KeyVal+xK_LaunchA = 0x1008ff4a+xK_LaunchB :: KeyVal+xK_LaunchB = 0x1008ff4b+xK_LaunchC :: KeyVal+xK_LaunchC = 0x1008ff4c+xK_LaunchD :: KeyVal+xK_LaunchD = 0x1008ff4d+xK_LaunchE :: KeyVal+xK_LaunchE = 0x1008ff4e+xK_LaunchF :: KeyVal+xK_LaunchF = 0x1008ff4f+xK_ApplicationLeft :: KeyVal+xK_ApplicationLeft = 0x1008ff50+xK_ApplicationRight :: KeyVal+xK_ApplicationRight = 0x1008ff51+xK_Book :: KeyVal+xK_Book = 0x1008ff52+xK_CD :: KeyVal+xK_CD = 0x1008ff53+xK_WindowClear :: KeyVal+xK_WindowClear = 0x1008ff55+xK_Close :: KeyVal+xK_Close = 0x1008ff56+xK_Copy :: KeyVal+xK_Copy = 0x1008ff57+xK_Cut :: KeyVal+xK_Cut = 0x1008ff58+xK_Display :: KeyVal+xK_Display = 0x1008ff59+xK_DOS :: KeyVal+xK_DOS = 0x1008ff5a+xK_Documents :: KeyVal+xK_Documents = 0x1008ff5b+xK_Excel :: KeyVal+xK_Excel = 0x1008ff5c+xK_Explorer :: KeyVal+xK_Explorer = 0x1008ff5d+xK_Game :: KeyVal+xK_Game = 0x1008ff5e+xK_Go :: KeyVal+xK_Go = 0x1008ff5f+xK_iTouch :: KeyVal+xK_iTouch = 0x1008ff60+xK_LogOff :: KeyVal+xK_LogOff = 0x1008ff61+xK_Market :: KeyVal+xK_Market = 0x1008ff62+xK_Meeting :: KeyVal+xK_Meeting = 0x1008ff63+xK_MenuKB :: KeyVal+xK_MenuKB = 0x1008ff65+xK_MenuPB :: KeyVal+xK_MenuPB = 0x1008ff66+xK_MySites :: KeyVal+xK_MySites = 0x1008ff67+xK_New :: KeyVal+xK_New = 0x1008ff68+xK_News :: KeyVal+xK_News = 0x1008ff69+xK_OfficeHome :: KeyVal+xK_OfficeHome = 0x1008ff6a+xK_Open :: KeyVal+xK_Open = 0x1008ff6b+xK_Option :: KeyVal+xK_Option = 0x1008ff6c+xK_Paste :: KeyVal+xK_Paste = 0x1008ff6d+xK_Phone :: KeyVal+xK_Phone = 0x1008ff6e+xK_Reply :: KeyVal+xK_Reply = 0x1008ff72+xK_Reload :: KeyVal+xK_Reload = 0x1008ff73+xK_RotateWindows :: KeyVal+xK_RotateWindows = 0x1008ff74+xK_RotationPB :: KeyVal+xK_RotationPB = 0x1008ff75+xK_RotationKB :: KeyVal+xK_RotationKB = 0x1008ff76+xK_Save :: KeyVal+xK_Save = 0x1008ff77+xK_ScrollUp :: KeyVal+xK_ScrollUp = 0x1008ff78+xK_ScrollDown :: KeyVal+xK_ScrollDown = 0x1008ff79+xK_ScrollClick :: KeyVal+xK_ScrollClick = 0x1008ff7a+xK_Send :: KeyVal+xK_Send = 0x1008ff7b+xK_Spell :: KeyVal+xK_Spell = 0x1008ff7c+xK_SplitScreen :: KeyVal+xK_SplitScreen = 0x1008ff7d+xK_Support :: KeyVal+xK_Support = 0x1008ff7e+xK_TaskPane :: KeyVal+xK_TaskPane = 0x1008ff7f+xK_Terminal :: KeyVal+xK_Terminal = 0x1008ff80+xK_Tools :: KeyVal+xK_Tools = 0x1008ff81+xK_Travel :: KeyVal+xK_Travel = 0x1008ff82+xK_UserPB :: KeyVal+xK_UserPB = 0x1008ff84+xK_User1KB :: KeyVal+xK_User1KB = 0x1008ff85+xK_User2KB :: KeyVal+xK_User2KB = 0x1008ff86+xK_Video :: KeyVal+xK_Video = 0x1008ff87+xK_WheelButton :: KeyVal+xK_WheelButton = 0x1008ff88+xK_Word :: KeyVal+xK_Word = 0x1008ff89+xK_Xfer :: KeyVal+xK_Xfer = 0x1008ff8a+xK_ZoomIn :: KeyVal+xK_ZoomIn = 0x1008ff8b+xK_ZoomOut :: KeyVal+xK_ZoomOut = 0x1008ff8c+xK_Away :: KeyVal+xK_Away = 0x1008ff8d+xK_Messenger :: KeyVal+xK_Messenger = 0x1008ff8e+xK_WebCam :: KeyVal+xK_WebCam = 0x1008ff8f+xK_MailForward :: KeyVal+xK_MailForward = 0x1008ff90+xK_Pictures :: KeyVal+xK_Pictures = 0x1008ff91+xK_Music :: KeyVal+xK_Music = 0x1008ff92+xK_Battery :: KeyVal+xK_Battery = 0x1008ff93+xK_Bluetooth :: KeyVal+xK_Bluetooth = 0x1008ff94+xK_WLAN :: KeyVal+xK_WLAN = 0x1008ff95+xK_UWB :: KeyVal+xK_UWB = 0x1008ff96+xK_AudioForward :: KeyVal+xK_AudioForward = 0x1008ff97+xK_AudioRepeat :: KeyVal+xK_AudioRepeat = 0x1008ff98+xK_AudioRandomPlay :: KeyVal+xK_AudioRandomPlay = 0x1008ff99+xK_Subtitle :: KeyVal+xK_Subtitle = 0x1008ff9a+xK_AudioCycleTrack :: KeyVal+xK_AudioCycleTrack = 0x1008ff9b+xK_CycleAngle :: KeyVal+xK_CycleAngle = 0x1008ff9c+xK_FrameBack :: KeyVal+xK_FrameBack = 0x1008ff9d+xK_FrameForward :: KeyVal+xK_FrameForward = 0x1008ff9e+xK_Time :: KeyVal+xK_Time = 0x1008ff9f+xK_SelectButton :: KeyVal+xK_SelectButton = 0x1008ffa0+xK_View :: KeyVal+xK_View = 0x1008ffa1+xK_TopMenu :: KeyVal+xK_TopMenu = 0x1008ffa2+xK_Red :: KeyVal+xK_Red = 0x1008ffa3+xK_Green :: KeyVal+xK_Green = 0x1008ffa4+xK_Yellow :: KeyVal+xK_Yellow = 0x1008ffa5+xK_Blue :: KeyVal+xK_Blue = 0x1008ffa6+xK_Suspend :: KeyVal+xK_Suspend = 0x1008ffa7+xK_Hibernate :: KeyVal+xK_Hibernate = 0x1008ffa8+xK_TouchpadToggle :: KeyVal+xK_TouchpadToggle = 0x1008ffa9+xK_TouchpadOn :: KeyVal+xK_TouchpadOn = 0x1008ffb0+xK_TouchpadOff :: KeyVal+xK_TouchpadOff = 0x1008ffb1+xK_AudioMicMute :: KeyVal+xK_AudioMicMute = 0x1008ffb2+xK_Switch_VT_1 :: KeyVal+xK_Switch_VT_1 = 0x1008fe01+xK_Switch_VT_2 :: KeyVal+xK_Switch_VT_2 = 0x1008fe02+xK_Switch_VT_3 :: KeyVal+xK_Switch_VT_3 = 0x1008fe03+xK_Switch_VT_4 :: KeyVal+xK_Switch_VT_4 = 0x1008fe04+xK_Switch_VT_5 :: KeyVal+xK_Switch_VT_5 = 0x1008fe05+xK_Switch_VT_6 :: KeyVal+xK_Switch_VT_6 = 0x1008fe06+xK_Switch_VT_7 :: KeyVal+xK_Switch_VT_7 = 0x1008fe07+xK_Switch_VT_8 :: KeyVal+xK_Switch_VT_8 = 0x1008fe08+xK_Switch_VT_9 :: KeyVal+xK_Switch_VT_9 = 0x1008fe09+xK_Switch_VT_10 :: KeyVal+xK_Switch_VT_10 = 0x1008fe0a+xK_Switch_VT_11 :: KeyVal+xK_Switch_VT_11 = 0x1008fe0b+xK_Switch_VT_12 :: KeyVal+xK_Switch_VT_12 = 0x1008fe0c+xK_Ungrab :: KeyVal+xK_Ungrab = 0x1008fe20+xK_ClearGrab :: KeyVal+xK_ClearGrab = 0x1008fe21+xK_Next_VMode :: KeyVal+xK_Next_VMode = 0x1008fe22+xK_Prev_VMode :: KeyVal+xK_Prev_VMode = 0x1008fe23+xK_LogWindowTree :: KeyVal+xK_LogWindowTree = 0x1008fe24+xK_LogGrabInfo :: KeyVal+xK_LogGrabInfo = 0x1008fe25

@@ -0,0 +1,104 @@+module IGE.Layout+  ( layoutGr )+  where++import Protolude hiding (force)+import IGE.Types+import Data.Graph.Inductive.Graph+import Data.Graph.Inductive.PatriciaTree+import qualified Data.Map.Strict as Map+import Data.Array+import Data.Array.MArray+import Data.Array.ST+import Control.Monad.ST+import Data.STRef+import Lens.Micro.Platform+import System.Random.MWC++data PEdge = Spring Double Double | Spacer Double Double++force :: PEdge -> ℂ -> ℂ -> ℂ+force (Spring k l) p1 p2 = ((k * (magnitude z - l)) :+ 0) * signum z+  where z = p2 - p1+force (Spacer k l) p1 p2 = ((max 0 (k * (magnitude z - l))) :+ 0) * signum z+  where z = p2 - p1++type Edges = Array (Int, Int) PEdge+type STNodes s = STArray s Int ℂ+type Nodes = Array Int ℂ++fdStep :: Double -> Edges -> STNodes s -> ST s Double+fdStep stepSize edges nodes = do+  let stepSizeC = stepSize :+ 0+  (0, n) <- getBounds nodes+  maxForceRef <- newSTRef 0+  forM_ [0..n] $ \i -> do+    fRef <- newSTRef $ 0 :+ 0+    p1 <- readArray nodes i+    forM_ [0..n] $ \j -> do+      p2 <- readArray nodes j+      let edge = edges ! (i, j)+      f <- readSTRef fRef+      writeSTRef fRef $ f + (force edge p1 p2)+    f <- readSTRef fRef+    let dp = stepSizeC * f+    writeArray nodes i $ p1 + dp+    maxF <- readSTRef maxForceRef+    if magnitude f > maxF+      then writeSTRef maxForceRef $ magnitude f+      else return ()+  maxF <- readSTRef maxForceRef+  return maxF++runFd :: Double -> Double -> Edges -> STNodes s -> ST s ()+runFd tolerance stepSize edges nodes = perturb >> loop+  where+    perturb = do+      gen <- create+      (0, n) <- getBounds nodes+      forM_ [0..n] $ \i -> do+        p <- readArray nodes i+        cθ <- uniformR (0, 2 * pi) gen+        cr <- uniformR (0, 0.2) gen+        writeArray nodes i (p + mkPolar cr cθ)+    loop = do+      f <- fdStep stepSize edges nodes+      if f > tolerance+        then loop+        else return ()++defaultSpring :: PEdge+defaultSpring = Spring 0.1 0.8+defaultSpacer :: PEdge+defaultSpacer = Spacer 0 0.5+defaultStepSize :: Double+defaultStepSize = 0.01+defaultTolerance :: Double+defaultTolerance = 0.001++initNodes :: Gr a b -> (Map.Map Node Int, Nodes)+initNodes g = ( Map.fromList $ zip (nodes g) [0..]+              , listArray (0, n - 1) $ (\k -> fromIntegral (k `rem` d) :+ fromIntegral (k `quot` d)) <$> [0..n-1])+  where+    n = length $ nodes g+    d = ceiling $ sqrt $ fromIntegral $ order g++initEdges :: Gr a b -> Map.Map Node Int -> Edges+initEdges g m = runSTArray $ do+    edgeMat <- newArray ((0, 0), (n - 1, n - 1)) defaultSpacer+    forM_ (over both (m Map.!) <$> edges g) $ \(n1, n2) -> do+      writeArray edgeMat (n1, n2) defaultSpring+      writeArray edgeMat (n2, n1) defaultSpring+    return edgeMat+  where+    n = length $ nodes g++layoutGr :: Gr n e -> Map.Map Node ℂ+layoutGr g = Map.map (nodeVec !) nodeMap+  where+    (nodeMap, frozenNodes) = initNodes g+    nodeVec = runSTArray $ do+      let edgeMat = initEdges g nodeMap+      nodeVec' <- thaw frozenNodes+      runFd defaultTolerance defaultStepSize edgeMat nodeVec'+      return nodeVec'

@@ -0,0 +1,101 @@+module IGE.Render+  ( renderEditorState )+  where++import Protolude+import IGE.Types+import IGE.Layout+import Data.Graph.Inductive.Graph+import Data.Graph.Inductive.PatriciaTree+import Graphics.Rendering.Cairo+import Lens.Micro.Platform+import qualified Data.Map.Strict as Map++-- Refactoring ideas:+-- - Use diagrams++instance Renderable Text where+  render s (x :+ y) = do+    extents <- textExtents s+    rectangle+      (x - textMargin)+      (y - (textExtentsHeight extents + textMargin))+      (textExtentsWidth extents + (2 * textMargin))+      (textExtentsHeight extents + (2 * textMargin))+    setSourceRGB 0.1 0.1 0.1+    fill+    setSourceRGB 0.9 0.9 0.9+    moveTo x y+    showText s++instance Renderable () where+  render () (x :+ y) = do+    arc x y nodeSize 0 (2 * pi)+    fill++instance RenderNode Text where++instance RenderEdge Text where++instance RenderNode () where++instance RenderEdge () where+  renderEdge _ _ = return ()++nodeSize :: Double+nodeSize = 4++renderBackground :: Render ()+renderBackground = do+  setSourceRGB 0.1 0.1 0.1+  paint+  setSourceRGB 0.9 0.9 0.9+  selectFontFace ("monospace" :: Text) FontSlantNormal FontWeightNormal+  setFontSize 15++renderNodes :: (RenderNode a) => [(ℂ, a)] -> Render ()+renderNodes nodes = mapM_ (uncurry $ flip renderNode) nodes++renderEdges :: (RenderEdge a) => [(ℂ, ℂ, a)] -> Render ()+renderEdges edges =+  forM_ edges $ \(p1@(x0 :+ y0), p2@(x1 :+ y1), label) -> do+    moveTo x0 y0+    lineTo x1 y1+    stroke+    renderEdge label $ (p1 + p2) / (2 :+ 0)++renderCommand :: (Int, Int) -> [Char] -> Render ()+renderCommand (w, h) s = do+  let s' = reverse s+  extents <- textExtents s'+  moveTo 0 ((fromIntegral h) - (textExtentsHeight extents))+  showText s'++textMargin = 3++renderLabels :: [([Char], ℂ)] -> Render ()+renderLabels labels =+  forM_ labels $ \(s, x :+ y) -> do+    extents <- textExtents s+    rectangle+      (x - textMargin)+      (y - (textExtentsHeight extents + textMargin))+      (textExtentsWidth extents + (2 * textMargin))+      (textExtentsHeight extents + (2 * textMargin))+    setSourceRGB 0.7 0.7 0.2+    fill+    setSourceRGB 0.1 0.1 0.1+    moveTo x y+    showText s++renderEditorState :: (RenderNode n, RenderEdge e) => EditorState n e -> (Int, Int) -> Render ()+renderEditorState es dims = do+  let rm = es^._rm+  let graph = es^._graph+  let labels = es^._labels+  let nodeMap = (rm ^*) <$> es^._nodeMap+  renderBackground+  renderEdges $ ((_1 %~ (nodeMap Map.!)) . (_2 %~ (nodeMap Map.!))) <$> labEdges graph+  renderNodes $ (_1 %~ (nodeMap Map.!)) <$> labNodes graph+  renderCommand dims (es^._cmd)+  renderLabels $ over _2 (nodeMap Map.!) <$> labels

@@ -0,0 +1,13 @@+module IGE.Serialization where++import Protolude hiding (ByteString)+import Data.Aeson+import Data.Graph.Inductive.Graph+import Data.Graph.Inductive.PatriciaTree+import Data.ByteString.Lazy++graphToBS :: (ToJSON n, ToJSON e) => Gr n e -> ByteString+graphToBS g = encode (labNodes g, labEdges g)++graphFromBS :: (FromJSON n, FromJSON e) => ByteString -> Maybe (Gr n e)+graphFromBS bs = uncurry mkGraph <$> decode bs

@@ -0,0 +1,115 @@+module IGE.Types where++import Protolude+import Data.Complex+import Data.Graph.Inductive.Graph+import Data.Graph.Inductive.PatriciaTree+import Lens.Micro.Platform+import Control.Concurrent.STM+import Conduit+import Graphics.UI.Gtk (KeyVal)+import Graphics.Rendering.Cairo+import qualified Data.Map.Strict as Map++-- Refactoring ideas:+-- - Use typeclass-based EditorState+-- - Use StateT based Keybinding -- use hoisting to promote pure functions+-- - ++type ℂ = Complex Double++class Translation a where+  _x :: Lens' a Double+  _y :: Lens' a Double++class Amplitwist a where+  _r :: Lens' a Double+  _θ :: Lens' a Double++instance Translation ℂ where+  _x f (x :+ y) = (:+ y) <$> f x+  _y f (x :+ y) = (x :+) <$> f x++instance Amplitwist ℂ where+  _r f z = (* z) . (:+ 0) . (/ r) <$> f r+    where r = magnitude z+  _θ f z = (* z) . cis . (+ (-θ)) <$> f θ+    where θ = phase z++class (Translation a, Amplitwist a) => RigidMotion a where+  (^.^) :: a -> a -> a+  (^*) :: a -> ℂ -> ℂ+  -- law = (a ^.^ b) ^* z = a ^* (b ^* c)++data RM = RM { rmAT :: ℂ, rmTrans :: ℂ } -- rigid motion+  deriving (Eq, Show)++makeLensesFor [("rmAT", "_at"), ("rmTrans", "_trans")] ''RM++instance Translation RM where+  _x f (RM at trans) = (RM at) <$> _x f trans+  _y f (RM at trans) = (RM at) <$> _y f trans++instance Amplitwist RM where+  _r f (RM at trans) = (flip RM trans) <$> _r f at+  _θ f (RM at trans) = (flip RM trans) <$> _θ f at++instance RigidMotion RM where+  (RM at1 trans1) ^.^ (RM at2 trans2) = RM (at1 * at2) (trans1 + (at1 * trans2))+  (RM at trans) ^* z = (z * at) + trans++class Renderable a where+  render :: a -> ℂ -> Render ()++class Renderable a => RenderNode a where+  renderNode :: a -> ℂ -> Render ()+  renderNode = render++class Renderable a => RenderEdge a where+  renderEdge :: a -> ℂ -> Render ()+  renderEdge = render++data EditorState n e = EditorState {+    esGraph :: Gr n e+  , esRM :: RM+  , esNum :: Int+  , esCommand :: [Char] -- stored backwards+  , esLabels :: [([Char], Node)]+  , esNodeMap :: Map.Map Node ℂ+  }++makeLensesFor [+    ("esGraph", "_graph")+  , ("esRM", "_rm")+  , ("esNum", "_num")+  , ("esCommand", "_cmd")+  , ("esLabels", "_labels")+  , ("esNodeMap", "_nodeMap")] ''EditorState++newtype IGEM n e a = IGEM { unIGEM :: ReaderT (TVar (EditorState n e)) IO a }+  deriving (Functor, Applicative, Monad, MonadIO, MonadReader (TVar (EditorState n e)))++runIGEM :: TVar (EditorState n e) -> IGEM n e a -> IO a+runIGEM v m = runReaderT (unIGEM m) v++type EditorM n e = State (EditorState n e)++runTVarState :: (MonadReader (TVar s) m, MonadIO m) => State s a -> m a+runTVarState action = do+  stateVar <- ask+  liftIO $ atomically $ do+    s <- readTVar stateVar+    let (a, s') = runState action s+    writeTVar stateVar s'+    return a++runTVarReader :: (MonadReader (TVar s) m, MonadIO m) => Reader s a -> m a+runTVarReader action = do+  stateVar <- ask+  s <- liftIO $ readTVarIO stateVar+  return $ runReader action s++data RefreshType = LayoutChange | NoLayoutChange+  deriving (Show, Eq)++type KeyBinding n e = ConduitM KeyVal RefreshType (IGEM n e)

@@ -0,0 +1,44 @@+module IGE.UI where++import Protolude hiding (on)+import Graphics.UI.Gtk hiding (get)+import Data.Graph.Inductive.Graph+import Data.Graph.Inductive.PatriciaTree+import Control.Concurrent.STM+import Control.Concurrent.STM.TBMChan++import IGE.Types+import IGE.Render+import IGE.Layout+import IGE.Control++runMainWindow :: (RenderNode n, RenderEdge e) => Gr n e -> RM -> KeyBinding n e () -> IO ()+runMainWindow initGr initRM keybinding = do+  void initGUI+  w <- windowNew+  da <- drawingAreaNew+  w `containerAdd` da+  editorState <- newTVarIO $ EditorState initGr initRM 3 "" [] (layoutGr initGr)+  keyChan <- newTBMChanIO 16++  _ <- forkIO $ runKeyBinding keyChan editorState w keybinding++  void $ (w `on` deleteEvent) $ liftIO mainQuit >> return True++  void $ (da `on` exposeEvent) $ liftIO $ do+    dw <- widgetGetDrawWindow da+    es <- readTVarIO editorState+    dims <- drawableGetSize dw+    renderWithDrawable dw $ renderEditorState es dims+    return True++  void $ (da `on` keyPressEvent) $ do+    kv <- eventKeyVal+    liftIO $ atomically $ writeTBMChan keyChan kv+    return True++  da `widgetSetCanFocus` True+  da `widgetAddEvents` [KeyPressMask]++  widgetShowAll w+  mainGUI

@@ -0,0 +1,17 @@+module Main where++import Protolude+import Data.Graph.Inductive.PatriciaTree+import Data.Graph.Inductive.Graph as Graph+import IGE.Types+import IGE.UI+import IGE.Control++sampleGr :: Gr () ()+sampleGr = mkGraph [(0, ()), (1, ()), (2, ())] [(0, 1, ()), (1, 2, ()), (0, 2, ())]++initRM :: RM+initRM = RM (100 :+ 0) (100 :+ 100)++main :: IO ()+main = runMainWindow Graph.empty initRM textKeyBinding