From: Tom Tromey Date: Wed, 7 Apr 1999 14:42:40 +0000 (+0000) Subject: Initial revision X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=ee9dd3721be68b9fa63dea9aa5a1d86e66958cde;p=gcc.git Initial revision From-SVN: r26263 --- diff --git a/libjava/COPYING.LIB b/libjava/COPYING.LIB new file mode 100644 index 00000000000..161a3d1d47b --- /dev/null +++ b/libjava/COPYING.LIB @@ -0,0 +1,482 @@ + GNU LIBRARY GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1991 Free Software Foundation, Inc. + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the library GPL. It is + numbered 2 because it goes with version 2 of the ordinary GPL.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Library General Public License, applies to some +specially designated Free Software Foundation software, and to any +other libraries whose authors decide to use it. You can use it for +your libraries, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if +you distribute copies of the library, or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link a program with the library, you must provide +complete object files to the recipients so that they can relink them +with the library, after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + Our method of protecting your rights has two steps: (1) copyright +the library, and (2) offer you this license which gives you legal +permission to copy, distribute and/or modify the library. + + Also, for each distributor's protection, we want to make certain +that everyone understands that there is no warranty for this free +library. If the library is modified by someone else and passed on, we +want its recipients to know that what they have is not the original +version, so that any problems introduced by others will not reflect on +the original authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that companies distributing free +software will individually obtain patent licenses, thus in effect +transforming the program into proprietary software. To prevent this, +we have made it clear that any patent must be licensed for everyone's +free use or not licensed at all. + + Most GNU software, including some libraries, is covered by the ordinary +GNU General Public License, which was designed for utility programs. This +license, the GNU Library General Public License, applies to certain +designated libraries. This license is quite different from the ordinary +one; be sure to read it in full, and don't assume that anything in it is +the same as in the ordinary license. + + The reason we have a separate public license for some libraries is that +they blur the distinction we usually make between modifying or adding to a +program and simply using it. Linking a program with a library, without +changing the library, is in some sense simply using the library, and is +analogous to running a utility program or application program. However, in +a textual and legal sense, the linked executable is a combined work, a +derivative of the original library, and the ordinary General Public License +treats it as such. + + Because of this blurred distinction, using the ordinary General +Public License for libraries did not effectively promote software +sharing, because most developers did not use the libraries. We +concluded that weaker conditions might promote sharing better. + + However, unrestricted linking of non-free programs would deprive the +users of those programs of all benefit from the free status of the +libraries themselves. This Library General Public License is intended to +permit developers of non-free programs to use free libraries, while +preserving your freedom as a user of such programs to change the free +libraries that are incorporated in them. (We have not seen how to achieve +this as regards changes in header files, but we have achieved it as regards +changes in the actual functions of the Library.) The hope is that this +will lead to faster development of free libraries. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, while the latter only +works together with the library. + + Note that it is possible for a library to be covered by the ordinary +General Public License rather than by this special one. + + GNU LIBRARY GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library which +contains a notice placed by the copyright holder or other authorized +party saying it may be distributed under the terms of this Library +General Public License (also called "this License"). Each licensee is +addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also compile or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + c) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + d) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the source code distributed need not include anything that is normally +distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Library 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 Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "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 +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY 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 +LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/libjava/ChangeLog b/libjava/ChangeLog new file mode 100644 index 00000000000..befc1522870 --- /dev/null +++ b/libjava/ChangeLog @@ -0,0 +1,5035 @@ +1999-04-06 Tom Tromey + + * gnu/gcj/protocol/http/Connection.java (getHeaderField): Catch + IOException from getHttpHeaders(). + (getHeaderFieldKey): Likewise. + + * include/javaprims.h: Regenerated declarations. + + * Makefile.in: Rebuilt. + * Makefile.am (ordinary_java_source_files): Updated for removed + files. + +1999-04-06 Per Bothner + + * java/util/zip/Adler32.java: New class. + * java/util/zip/CRC32.java: Add working method bodies. + * Makefile.am (ordinary_java_source_files): Add new Adler32 class. + * Makefile.in: Re-generate. + +Tue Apr 6 18:28:42 1999 Warren Levy + + * gnu/gcj/protocol/http/Connection.java: New file. Rewritten + from version in removed www hierarchy. + * gnu/gcj/protocol/http/Handler.java: New file. Copied from + version in removed www hierarchy. + + * gnu/gcj/www/protocol/http/Connection.java: Removed. + * gnu/gcj/www/protocol/http/Handler.java: Removed. + * gnu/gcj/www/protocol/http: Removed dir. + * gnu/gcj/www/protocol: Removed dir. + * gnu/gcj/www: Removed dir. + + * java/net/HttpURLConnection.java: Revised comments to indicate + missing JDK 1.2 methods. + + * java/net/URL.java (setURLStreamHandler): Look in gnu/gcj/protocol + hierarchy rather than the gnu/gcj/www/protocol one. + * java/net/URLConnection.java: Updated status comments. + (setContentHandler): Look in gnu/gcj/content hierarchy rather than + the gnu/gcj/www/content one. + +1999-04-06 Per Bothner + + * Makefile.am (JIS0208_to_Unicode.cc, JIS0212_to_Unicode.cc): + The gen-from-JIS program is in $(CONVERT_DIR). + +1999-04-06 Tom Tromey + + * mauve-libgcj: Renamed from mauve-libjava. + +Tue Apr 6 03:18:38 1999 Warren Levy + + * java/net/HttpURLConnection.java (getResponseCode): Implemented. + (getResponseMessage): Implemented. + (getResponseVals): New private method. + + * java/net/URLConnection.java (getContent): Implemented. + (setContentHandler): Convert non-alphabetic/numeric chars per spec. + +1999-04-05 Tom Tromey + + * Makefile.am (bin_PROGRAMS): Renamed convert to jv-convert. + (jv_convert_SOURCES): Renamed. + (EXTRA_jv_convert_SOURCES): Likewise. + (jv_convert_LDFLAGS): Likewise. + (jv_convert_LINK): Likewise. + (jv_convert_LDADD): Likewise. + (jv_convert_DEPENDENCIES): Likewise. + + * Makefile.in: Rebuilt. + * Makefile.am (toolexeclibdir): Reference toolexecdir, not + tooldir. + +Mon Apr 5 02:14:35 1999 Warren Levy + + * java/net/HttpURLConnection.java (setRequestMethod): Use String.equals + method for comparison. + + * java/net/URLConnection.java (getContentLength): Implemented. + (getContentType): Implemented. + (getContentEncoding): Implemented. + (getExpiration): Implemented. + (getDate): Implemented. + (getLastModified): Implemented. + (getHeaderFieldInt): Implemented. + (getHeaderFieldDate): Implemented. + +Fri Apr 2 18:04:52 1999 Warren Levy + + * java/net/URLConnection.java (toString): Implemented. + (setContentHandlerFactory): Implemented. + (setContentHandler): Wrote new private helper method. + +1999-04-01 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am ($(java_source_files:.java=.class): Reverted change + of 1999-03-31; we always want to build all the .class files. + Depend on java_source_files, not libgcj.zip. + (nat_headers): Define in terms of ordinary_java_source_files. + +1999-03-31 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (special_java_source_files): New macro. + (java_source_files): Use it. + (ordinary_java_source_files): New macro. + (java_source_files): Use it. + ($(ordinary_java_source_files:.java=.class)): Renamed to avoid + creating headers for those files with hand-maintained headers. + + * include/javaprims.h: Regenerated namespace declarations. + * classes.pl (scan): Include [0-9] in regexp for matching class + names; for java.util.zip.CRC32. + + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Redefined to generate all possible + header files. + + * java/util/zip/ZipException.java: In package java.util.zip, not + java.net. + +1999-03-30 Tom Tromey + + * configure: Rebuilt. + * configure.in (EH_COMMON_INCLUDE): Look in ../compat-include for + eh-common.h when not building in tree with gcc. + + * Makefile.in: Rebuilt. + * Makefile.am ($(nat_files) $(GCOBJS) $(THREADOBJS) + $(libgcj_a_OBJECTS)): Changed how we list files that depend on + nat_headers. + ($(java_source_files:.java=.class)): New target. + + * Makefile.in: Rebuilt. + * Makefile.am (java_source_files): Added + java/net/HttpURLConnection.java and + gnu/gcj/www/protocol/http/Connection.java. + +Tue Mar 30 15:20:45 1999 Warren Levy + + * gnu/gcj/www/protocol/http/Connection.java: New file. + * gnu/gcj/www/protocol/http/Handler.java (openConnection): Implemented. + * java/net/HttpURLConnection.java: New file. + * java/net/URLConnection.java (getHeaderField): Implemented default. + (getHeaderFieldKey): Implemented default method. + +1999-03-30 Tom Tromey + + * gnu/gcj/convert/JIS0212.h, gnu/gcj/convert/JIS0208.h: Rebuilt. + + * java/util/zip/Deflater.java: Added copyright header. + * java/util/zip/CRC32.java: Added copyright header. + + * Makefile.am ($(srcdir)/$(CONVERT_DIR)/JIS0208.h): Note in file + that it is automatically generated. + ($(srcdir)/$(CONVERT_DIR)/JIS0212.h): Likewise. + + * gnu/gcj/convert/BytesToUnicode.java, + gnu/gcj/convert/Convert.java, gnu/gcj/convert/Input_8859_1.java, + gnu/gcj/convert/Input_EUCJIS.java, + gnu/gcj/convert/Input_UTF8.java, + gnu/gcj/convert/JIS0208_to_Unicode.cc, + gnu/gcj/convert/JIS0212_to_Unicode.cc, + gnu/gcj/convert/Output_8859_1.java, + gnu/gcj/convert/Output_JavaSrc.java, + gnu/gcj/convert/Output_UTF8.java, + gnu/gcj/convert/UnicodeToBytes.java, + gnu/gcj/convert/natInput_EUCJIS.cc: Added copyright headers. + + * gnu/gcj/convert/gen-from-JIS.c (main): Fixed incorrect fprintf. + + * Makefile.in, configure: Rebuilt. + * configure.in (TESTSUBDIR): Enable if testsuite subdir exists, + not if test subdir exists. + (--enable-gcj-classes): Removed; gcj always used to generate + .class files. + (JAVA, JAVAC): Removed. + (--enable-single-compilation, --enable-source-compilation): + Removed. + (here): New subst. + (NATIVE): New conditional. + * Makefile.am (toolexecdir): Renamed from tooldir to allow + `install-exec' to work. + (toolexeclibdir): Likewise. + (toollib_LIBRARIES): Likewise. + (AM_MAKEFLAGS): Don't pass tooldir. + (JAVAC): New macro. + (javao_files): Redefined. + (java_source_files): New macro. + (c_source_files): New macro. + (c_files): Redefined in terms of c_source_files. + (java_io_files, java_lang_files, java_net_files, java_text_files, + java_util_files, gnu_files, java_files): Removed. + (class_io_files, class_lang_files, class_net_files, + class_text_files, class_util_files, class_gnu_files, class_files): + Removed. + (nat_source_files): New macro. + (nat_files): Redefined in terms of nat_source_files. + (EXTRA_libgcj_a_SOURCES): Added c_source_files, + java_source_files. Removed no-such-file.c. + (here): Removed. + (ETAGS_ARGS): Removed. + (TAGS_DEPENDENCIES): Likewise. + (libgcj.zip): Depend on java_source_files. Use $(here) and not + pwd in rule. + (src_io_files, src_lang_files, src_text_files, src_util_files, + src_gnu_files): Removed. + Removed ALL_AT_ONCE and COMPILE_FROM_CLASS code. + (BUILT_SOURCES): Removed. + (header-check): New target. + (javadir): Removed. + (noinst_PROGRAMS): New macro. + ($(srcdir)/$(CONVERT_DIR)/JIS0208_to_Unicode.cc): Conditionalize + on MAINTAINER_MODE. + ($(srcdir)/$(CONVERT_DIR)/JIS0212_to_Unicode.cc): Likewise. + (gen-from-JIS): Build in top directory. + (convert_source_files): New macro. + (convert_SOURCES): New macro. + (convert_LDFLAGS): Likewise. + (convert_LINK): Likewise. + (convert_LDADD): Likewise. + (convert_DEPENDENCIES): Likewise. + (convert): Removed. + (gen-from-JIS): Removed. + (gen_from_JIS_SOURCES): New macro. + (gen_from_JIS_LDADD): Likewise. + (gen_from_JIS_DEPENDENCIES): Likewise. + + * configure: Rebuilt. + * configure.in (CANADIAN): Set to `yes', not `canadian'. + (NULL_TARGET): Initialize to `no'. Correctly examine $NULL_TARGET + when defining conditional. + +Tue Mar 30 10:36:27 1999 Per Bothner + + * gnu/gcj/convert/{JIS0208.TXT,JIS0212.TXT}: Remove these files. + The Unicode Consortium does not permit their re-distribution. + * Makefile.am, Makefile.in: Add comments with URLs for removed files. + (JIS0208.h, JIS0212.h): Do not depend on removed files. + +Mon Mar 29 18:58:13 1999 Per Bothner + + * natSystem.c (init_properties): Use malloc, realloc, free after all. + +Mon Mar 29 13:41:02 1999 Per Bothner + + * gnu/gcj/convert/{JIS0208.TXT,JIS0212.TXT}: New mapping tables + from Unicode Consortium. + * gnu/gcj/convert/{JIS0208.h,JIS0212.h}: New generated headers. + * gnu/gcj/convert/gen-from-JIS.c: New utility for maintainers only. + * gnu/gcj/convert/{JIS0208_to_Unicode.cc,JIS0212_to_Unicode.cc}: + New tables, generated using gen-from-JIS. + * gnu/gcj/convert/Output_JavaSrc.java: New UnicodeToBytes class. + * gnu/gcj/convert/Output_UTF8.java: Fix bug. + * gnu/gcj/convert/Input_EUCJIS.java: New BytesToUnicode class. + * gnu/gcj/convert/natInput_EUCJIS.cc: Native methods for new class. + + * gnu/gcj/convert/Convert.java: New application. + * Makefile.am, Makefile.in (convert): New program, using Convert. + Build the various JIS conversion tables (in maintainer mode). + +Fri Mar 26 16:51:30 1999 Warren Levy + + * gnu/gcj/www/protocol/http/Handler.java: New file - stubbed. + + * java/net/URL.java (URL): Deal with null property value. Use "." + as separator in building class name. + * java/net/URLConnection.java: Implemented majority of stubbed methods. + * java/net/URLStreamHandler.java (parseURL): Use "" in string + manipulations instead of 'null'. Comment cleanup. Use 0 for the + beginning of the substring rather than 'start'. + +1999-03-26 Tom Tromey + + * include/java-chartables.h: Rebuilt. + * include/java-chardecomp.h: New file. + * chartables.pl: Generate output files directly. Added support + for generating decomposition header. + (canonical_decomposition, full_decomposition): New globals. + (DECOMPOSITION): New constant. + (process_char): Call add_decomposition. + (add_decomposition): New sub. + (write_decompositions): New sub. + +1999-03-25 Tom Tromey + + * java/text/CollationElementIterator.java: New file. + + * mauve-libjava: Omit StringTest. + +Wed Mar 24 15:17:49 1999 Warren Levy + + * java/net/URL.java (URL(URL, String, URLStreamHandler)): Allow URLs + without a '/' when parsing protocol. Handle ref outside of parseURL. + (hashCode): Implemented. + (set): Don't expand -1 to default port. + (getDefaultPort): Removed. + + * java/net/URLStreamHandler.java (parseURL): Implemented. + (toExternalForm): Implemented. + +1999-03-23 Tom Tromey + + * java/text/BreakIterator.java (getSentenceInstance): + Implemented. + * gnu/gcj/text/SentenceBreakIterator.java: New file. + + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added IllegalAccessException. + * java/lang/natClass.cc (newInstance): Throw + IllegalAccessException, not IllegalAccessError. + Include IllegalAccessException.h. + +1999-03-22 Tom Tromey + + * gnu/gcj/text/LineBreakIterator.java: New file. + * java/text/BreakIterator.java (getLineInstance): Implemented. + + * gnu/gcj/text/WordBreakIterator.java (WordBreakIterator): Made + copy constructor private. + (previous, next): Removed erroneous comment about line + separators. + (previous): Correctly recognize break between non-letter on the + left and letter on the right. Handle apostrophes correctly. + + * java/text/BreakIterator.java (getWordInstance): Implemented. + * gnu/gcj/text/WordBreakIterator.java: New file. + * gnu/gcj/text/CharacterBreakIterator.java: Extend + BaseBreakIterator. + * gnu/gcj/text/BaseBreakIterator.java: New file. + +1999-03-19 Tom Tromey + + * java/text/BreakIterator.java: New file (partially stubbed out). + * gnu/gcj/text/CharacterBreakIterator.java: New file. + + * include/config.h.in: Rebuilt. + * acconfig.h (STRUCT_TM_HAS_GMTOFF): New define. + (HAVE_TIMEZONE): Likewise. + * configure: Rebuilt. + * configure.in: Added timezone checks. + * java/util/natGregorianCalendar.cc (computeTime): Adjust for + timezone. + +Fri Mar 19 15:26:35 1999 Per Bothner + + * gnu/gcj/convert/BytesToUnicode.java: New abstract class. + * gnu/gcj/convert/UnicodeToBytes.java: New abstract class. + * gnu/gcj/convert/Input_8859_1.java: New BytesToUnicode sub-class. + * gnu/gcj/convert/Input_UTF8.java: New BytesToUnicode sub-class. + * gnu/gcj/convert/Output_8859_1.java: New UnicodeToBytes sub-class. + * gnu/gcj/convert/Output_UTF8.java: New UnicodeToBytes sub-class. + * java/io/InputStreamReader.java: Rewrite to use BytesToUnicode. + * java/io/OutputStreamWriter.java: Rewrite to use UnicodeToBytes. + + * java/io/natFileDescriptorPosix.cc (open): Use O_BINARY flag. + (BSD_COMP): Kludge needed for Solaris2. + +Fri Mar 19 01:49:46 1999 Warren Levy + + * java/net/URL.java (URL(java.net.URL, string): Moved code to + URL(java.net.URL, string, URLStreamHandler) and call it with a + null handler. In latter constructor, added SecurityManager check. + (set): Expect null handler on bad protocol rather than an exception. + (setURLStreamHandler): Simplified exception handling; return null + on invalid protocol. + +1999-03-18 Tom Tromey + + * java/text/DecimalFormat.java (format(long,...)): Rewrote. + + * java/lang/natSystem.cc (setOut, setIn, setErr): New native + methods. + Include PrintStream.h, InputStream.h. + * java/lang/System.java (ForwardingInputStream, + ForwardingOutputStream): Removed. + (setErr, setIn, setOut): Now native. + + Reverted patch from 1999-02-12 to work around problem in + libgcc2.c. + * exception.cc (_Jv_eh_alloc): Use malloc, not _Jv_AllocBytes. + (_Jv_eh_free): Use free. + + * java/io/natFileDescriptorPosix.cc (open): Allocate enough space + for path name. Minor formatting fixes. + + * boehm.cc (_Jv_MarkObj): Always mark `methods' field. + + * prims.cc (fail_on_finalization): New function. + (_Jv_GCWatch): Likewise. + + * prims.cc (JvRunMain): Initialize `nullp'. + (nullp): New global. + (catch_segv): Throw nullp. + + * Makefile.in: Rebuilt. + * Makefile.am (ZIP): In "null target" case, zip is found in the + build tree. + + * prims.cc (_Jv_PrimClass): Initialize all elements of class + object. + Include Modifier.h. + + * java/lang/StringBuffer.java (StringBuffer): Don't use + ensureCapacity to set initial capacity. + (capacity): Subtract `length' from return result. + +Thu Mar 18 01:53:35 1999 Warren Levy + + * java/io/natFileDescriptorPosix.cc (open): Throw + FileNotFoundException, but with filename and errno in msg. + +Wed Mar 17 11:09:30 1999 Warren Levy + + * gnu/gcj/www/protocol/URLStreamHandlerFactory.java: Removed; + functionality folded into java/net/URL.java per spec. + + * java/io/natFileDescriptorPosix.cc (open): Check for ENOENT rather + than EEXIST for throwing FileNotFoundException. + + * java/net/URL.java: Folded in default URLStreamHandlerFactory + algorithm per JDK 1.2 doc. Added SecurityManager checks. + + * java/net/URLStreamHandler.java (parseURL): Added stub. + +1999-03-15 Andrew Haley + + * java/text/ChoiceFormat.java (nextDouble): Simplify and fix off + by one errors. + +1999-03-15 Andrew Haley + + * java/lang/natSystem.cc (currentTimeMillis): Restore eCos clock + support. + +1999-03-12 Tom Tromey + + * prims.cc (catch_segv): New function. + Include if HANDLE_SEGV defined. Include + NullPointerException.h. + (JvRunMain): If HANDLE_SEGV defined, install catch_segv as SIGSEGV + handler. + + * java/text/SimpleDateFormat.java (equals): Ensure that object is + a SimpleDateFormat, not just a DateFormat. + (defaultCenturyStart, formatData, pattern): Now private. + (append): Now `final'. Use `NumberFormat.format'. + (parse): Wrote. + (SimpleDateFormat): Turn off groupin in NumberFormat object. + + * java/lang/natString.cc (indexOf): Add `fromIndex' to successful + result. + + * java/text/MessageFormat.java (format): Use default MessageFormat + constructor. + (parse, parseObject): Wrote. + + * java/text/SimpleDateFormat.java (SimpleDateFormat): Wrote no-arg + constructor. + +1999-03-12 Andrew Haley + + * java/lang/String.java (indexOf): Replace with native method for + better performance. + * java/lang/natString.cc (IndexOf): As above. + + * java/lang/natString.cc (init(jbyteArray,jint,jint,jint)): + Argument check corrected. + (init(jbyteArray,jint,jint,jstring)): Likewise. + + * java/lang/StringBuffer.java (ensureCapacity): Replace with JDK + 1.2 compliant method. + + * java/lang/Double.java (byteValue, shortValue): JDK 1.1 methods + added. + * java/lang/Float.java (byteValue, shortValue): Likewise. + +1999-03-11 Tom Tromey + + * java/text/DecimalFormat.java (parse): Wrote. + + * java/text/ChoiceFormat.java (parse): Set error index on + ParsePosition object. + + * java/lang/Integer.java (parseInt): Throw exception on overflow + when intermediate result is most negative number. Changed + overflow detection as well. + * java/lang/Long.java (parseLong): Likewise. + + * configure, Makefile.in: Rebuilt. + * configure.in (NULL_TARGET, CANADIAN): New conditionals. Set + CANADIAN when building in source tree that doesn't include gcc. + * Makefile.am (ZIP, GCJ, GCJH): Use automake conditionals to + define. + + * java/text/ChoiceFormat.java (nextDouble): Correct some + off-by-one errors when masking or adding. + + * java/text/DecimalFormat.java (format): Fill in FieldPosition + parameter, if given. Use `%', not IEEEremainder. + (scanFix): Throw error if multiplier already set. + (computePattern): Wrote. + +1999-03-11 Andrew Haley + + * java/text/ChoiceFormat.java (mantissaBits): Use correct value of + 52. + (nextDouble): Corrected masking logic. Handle interaction between + `next' and negative numbers. + +Wed Mar 10 18:58:37 1999 Warren Levy + + * gnu/gcj/www/protocol/URLStreamHandlerFactory.java: Created. + * java/net/URL.java: Added general comments. + +1999-03-10 Tom Tromey + + * java/text/ChoiceFormat.java (parse): Wrote. + + * java/text/ChoiceFormat.java (toPattern): Use `#', not `<'. + + * java/text/MessageFormat.java (MessageFormatElement.setLocale): + Create ChoiceFormat objects. + (format): Special-case ChoiceFormat. + (scanFormatElement): Include { and } in generated style string. + +1999-03-09 Tom Tromey + + * java/text/ChoiceFormat.java: New file. + +Tue Mar 9 17:09:18 1999 Warren Levy + + * java/net/BindException.java: Created. + * java/net/ConnectException.java: Created. + * java/net/ContentHandler.java: Created. + * java/net/ContentHandlerFactory.java: Created. + * java/net/FileNameMap.java: Created. + * java/net/MalformedURLException.java: Created. + * java/net/NoRouteToHostException.java: Created. + * java/net/ProtocolException.java: Created. + * java/net/ServerSocket.java (@author): Fixed typo. + * java/net/Socket.java (@author): Fixed typo. + * java/net/SocketImpl.java (@author): Fixed typo. + * java/net/SocketImplFactory.java (@author): Fixed typo. + * java/net/URL.java: Created - nearly complete. + * java/net/URLConnection.java: Created - near-empty stub. + * java/net/URLStreamHandler.java: Created - incomplete stub. + * java/net/URLStreamHandlerFactory.java: Created. + * java/net/UnknownServiceException.java: Created. + +1999-03-09 Tom Tromey + + * java/lang/System.java (ForwardingInputStream): New class. + (ForwardingOutputStream): Likewise. + (in, out, err): Now `final' forwarding streams. + (setIn, setOut, setErr): Use appropriate method on forwarding + streams. + + * java/text/MessageFormat.java (MessageFormatElement): Now `final' + class. + +Tue Mar 9 12:16:53 1999 Per Bothner + + * java/util/zip/CRC32.java: New class (just an incomplete stub). + * java/util/zip/Checksum.java: New interface (complete). + * java/util/zip/Deflater.java: New class (near-empty stub). + * java/util/zip/DeflaterOutputStream.java: New class (incomplete stub). + * java/util/zip/ZipConstants.java: New interface (near-empty stub). + * java/util/zip/ZipEntry.java: New class (complete). + * java/util/zip/ZipException.java: New class (complete). + * java/util/zip/ZipFile.java: New class (incomplete stub). + * java/util/zip/ZipOutputStream.java: New class (incomplete stub). + +1999-03-09 Tom Tromey + + * java/text/MessageFormat.java (MessageFormatElement): Removed + `public' specifiers. + + * java/text/DecimalFormat.java (scanFormat): Increment index + before processing exponential format. Fixed a couple typos in + exception messages. + (format): Correct normalization of exponent. + +1999-03-08 Tom Tromey + + * java/text/SimpleDateFormat.java (parse): Throw + IllegalArgumentException, not ParseException. + +1999-03-05 Tom Tromey + + * java/text/SimpleDateFormat.java (SimpleDateFormat): Use locale + when constructing DateFormatSymbols. Initialize numberFormat + field of superclass. + + * java/text/DateFormat.java (equals): Rewrote. + (getAvailableLocales): New method. + (getDateInstance): New methods. + (getDateTimeInstance): Likewise. + (getTimeInstance): Likewise. + (getInstance): New method. + (computeInstance): New method. + + * java/text/DateFormatSymbols.java (zoneStringsDefault): Completed + for US. + (safeGetResource): New method. + (DateFormatSymbols): Use Locale paramater. + (equals): Now protected. + Made instance variables private. + +1999-03-04 Tom Tromey + + * java/text/DecimalFormat.java: New file. + + * java/text/NumberFormat.java (groupingUsed, + maximumFractionDigits, maximumIntegerDigits, + minimumFractionDigits, minimumIntegerDigits, parseIntegerOnly): + New fields. + (setDecimalSeparatorAlwaysShown, setMultiplier, + setPositivePrefix): Removed. + (setMinimumFractionDigits, setMaximumFractionDigits): + Implemented. + (format): Now final. + Added many new methods. + + * Makefile.in: Rebuilt. + * Makefile.am (gnu_files): New macro. + (java_files): Added gnu_files. + (class_gnu_files): New macro. + (class_files): Use it. + (src_gnu_files): New macro. + (gnu.o): New target. + (javao_files): Added gnu.o. + + * gnu/gcj/text/LocaleData_en_US.java: New file. + * gnu/gcj/text/LocaleData_en.java: New file. + * java/text/DecimalFormatSymbols.java: Import ResourceBundle. + (DecimalFormatSymbols): Use ResourceBundle to find resources. + (safeGetString): New method. + (safeGetChar): Likewise. + +1999-03-03 Tom Tromey + + * java/text/NumberFormat.java (INTEGER_FIELD, FRACTION_FIELD): New + constants. + + * java/text/FieldPosition.java (equals): Don't check for null + object; instanceof does this. + + * java/util/Locale.java (clone): New method. + (equals): Likewise. + +Wed Mar 3 17:20:15 1999 Anthony Green + + * doc/cni.sgml: New file. + +1999-03-03 Tom Tromey + + * prims.cc (_Jv_Abort): Mention libgcj, not libjava. + + * java/text/DecimalFormatSymbols.java: New file. + +1999-03-02 Tom Tromey + + * java/io/natFileDescriptorPosix.cc: Include sys/filio.h if it + exists. + * configure: Rebuilt. + * configure.in: Check for sys/filio.h. + + * java/lang/Runtime.java (checkLink): Throw NullPointerException + if required. + (load): Always throw UnsatisfiedLinkError. + (loadLibrary): Likewise. + +1999-03-02 Anthony Green + + * LIBGCJ_LICENSE: New file. + * LIBJAVA_LICENSE: Removed. + * Many files: libjava now libgcj. + +1999-03-02 Tom Tromey + + * include/java-chartables.h: Rebuilt. + * chartables.pl (print_block): Make table `const'. + (print_numerics): Likewise. + (print_single_map): Likewise. + (print_all_block): Likewise. + (print_case_table): Likewise. + (print_fast_tables): Likewise. + * java/lang/natCharacter.cc (table_search): `table' argument now + const. + +1999-03-01 Tom Tromey + + * java/util/Date.java (before, after): Inverted logic. + + * java/util/Date.java (parse): Handle case where first character + in string is open parenthesis. + (skipParens): Rewrote. + + * java/lang/reflect/natArray.cc: Include . + * java/lang/reflect/natField.cc: Include . + + * java/util/Date.java (parse): Correctly compute beginning of + punctuation. + + * java/util/Hashtable.java (get): Throw NullPointerException if + key is null. + (containsKey): Likewise. + + * java/util/Properties.java (list): Truncate value to 37 + characters and add `...'. + + * java/lang/Byte.java (parseByte): Pass `radix' to + Integer.parseInt. + + * prims.cc (_Jv_Abort): In non-DEBUG case, use System.err, not + fprintf. + Include System.h, PrintStream.h. + + * java/lang/natSystem.cc (init_properties): Don't use malloc, + realloc, or free. + + * java/lang/natSystem.cc (init_properties): Use getpwuid_r if it + exists. + * configure: Rebuilt. + * configure.in: Check for getpwuid_r. Look for `pwd.h', not + `pwd.d'. + + * mauve-libjava: Omit AttibutedCharacterIterator, ACIAttribute. + + * java/lang/SecurityManager.java: Import java.net.*. + (checkMulticast): New methods. + +Fri Feb 26 14:54:52 1999 Per Bothner + + * Makefile.am, Makefile.in (java/lang/reflect/Method.h): New rule. + (nat_files): Add java/lang/reflect/natArray.o. + (nat_headers): Add Field.h and NoSuchFieldException.h. + + * include/java-field.h (_Jv_GetStaticLongField, _Jv_GetStaticIntField, + _Jv_GetStaticShortField, _Jv_GetStaticByteField): New inline methods. + (_Jv_FromReflectedField): Fix buglet. + * include/jvm.h (_Jv_NewMultiArray): New declaration. + * include/java-assert.h (JvFail): Pass message string to _Jv_Abort. + * prims.cc (_Jv_Abort): Include message in print-out. + + * prims.cc (_Jv_equal): New method (compare Utf8Const and jstring). + (new_multi_array): Rename to _Jv_NewMultiArray. Make non-static. + * include/jvm.h (_Jv_NewMultiArray, _Jv_equal): New declarations. + + * configure.in (AC_CHECK_HEADERS), configure: Add pwd.h. + * include/config.h.in (HAVE_PWD_H): New feature macro. + * java/lang/natSystem.cc (init_properties): Set file.encoding, + user.name, user.home, user.dir. + + * java/lang/reflect/Array.java: New class. + * java/lang/reflect/natArray.cc: New native methods. + * include/javaprims.h: Declare java::lang::reflect::Array. + + * java/lang/Class.h (getField): New private method. Add friends. + * java/lang/Class.java (getField): Add private overload. + * java/lang/natClass.cc (getField, getField, getDeclaredField, + getDeclaredMethods): Add working implementations. + * java/lang/reflect/Field.java, java/lang/reflect/natField.cc: + Finish implementation, except for access control. + + * java/lang/reflect/Modifier.java (toString): New overload. + * include/java-method.h: New file. + * java/lang/reflect/Method.java (index): Replaced by offset field. + Remove various private fields - get them from _Jv_Field instead. + * java/lang/reflect/natMethod.cc (getModifiers, getName, getType): + New method implementations. + + * java/text/NumberFormat.java: Add a bunch of methods. + +Mon Feb 22 17:52:34 1999 Per Bothner + + * java/lang/StringBuffer.java (getChars): Fix bounds checks. + +1999-02-26 Tom Tromey + + * include/config.h.in: Rebuilt. + * acconfig.h (GETHOSTBYNAME_R_RETURNS_INT, + GETHOSTBYADDR_R_RETURNS_INT, HAVE_GETHOSTBYNAME_R, + HAVE_GETHOSTBYADDR_R): New defines. + * java/net/natInetAddress.cc (lookup): Use gethostbyname_r and + gethostbyaddr_r if available. + Include . + * configure: Rebuilt. + * configure.in: Check for gethostbyname_r, gethostbyaddr_r. + + * java/net/natInetAddress.cc (aton): Use _Jv_AllocBytesChecked. + Don't use JvFree. + (lookup): Likewise. + Include . + * include/jvm.h (_Jv_AllocBytesChecked): Declare. + * prims.cc (_Jv_AllocBytesChecked): New function. + + * Makefile.in: Rebuilt. + * Makefile.am (SUBDIRS): Removed `test'. + * configure: Rebuilt. + * configure.in: Don't build test/Makefile. + * test/*: Removed all files. + +Thu Feb 25 17:27:37 1999 Warren Levy + + * java/lang/reflect/Constructor.java: Make class final to match spec. + * java/lang/reflect/Method.java: Ditto. + +1999-02-25 Tom Tromey + + * java/net/natInetAddress.cc: Include before + . + * java/net/natPlainSocketImpl.cc: Include before + . + + * java/net/natInetAddress.cc: Declare gethostname if required. + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_GETHOSTNAME_DECL): New define. + * configure: Rebuilt. + * configure.in: Define HAVE_GETHOSTNAME_DECL when gethostname is + declared in unistd.h. + +1999-02-24 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (java/io/FileDescriptor.h): Removed target. + * java/io/FileDescriptor.java (FileDescriptor): Changed protection + from private to "none". + + * include/javaprims.h: Regenerated class declarations with new + classes.pl. + * classes.pl (scan): Only generate decls for java.lang, java.io, + and java.util. + +1999-02-24 Tom Tromey + + * posix-threads.cc (_Jv_InitThreads): Mask SIGINT in all threads. + (_Jv_ThreadWait): Allow SIGINT to be delivered to waiting thread. + +1999-02-23 Tom Tromey + + * java/util/natGregorianCalendar.cc (_REENTRANT): Only define if + not already defined. + * java/io/natFile.cc (_REENTRANT): Only define if not already + defined. + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_BOEHM_GC): New define. + * configure: Rebuilt. + * configure.in: Define HAVE_BOEHM_GC if using it. + * posix-threads.cc: Include boehm-config.h and gc.h if + HAVE_BOEHM_GC. + * include/posix-threads.h: Added explanatory note about Boehm GC. + + * java/io/BufferedReader.java (readLine): Only return null when + EOF seen before any characters read. (In particular, an empty + line should not return null.) + + * java/io/BufferedInputStream.java (read): Only refill once per + invocation. + + * mauve-libjava: Added java.text.StringCharacterIterator.iter, + java.lang.Character.classify12, java.lang.String.hash, + java.text.FieldPosition.Test, java.text.ParsePosition.Test, + java.text.SimpleDateFormat.getAndSet2DigitYearStart + + * java/text/StringCharacterIterator.java (setIndex): No error if + index == end. + (next): Check for `pos == end', not `end - 1'. + (StringCharacterIterator): Allow `pos == end'. Explicitly check + for null text in each constructor. + (clone): Fixed order of arguments to constructor. + +1999-02-22 Tom Tromey + + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_INET6): New define. + (HAVE_SOCKLEN_T): Likewise. + * java/net/PlainSocketImpl.java: Added copyright header. + * java/net/natPlainSocketImpl.cc: Added copyright header. + (union SockAddr): Use HAVE_INET6, not AF_INET6. + (bind): Likewise. + (connect): Likewise. + (accept): Likewise. + (socklen_t): New typedef. + (accept): Use socklen_t. + * java/net/natInetAddress.cc: Added copyright header. + (HAVE_GETHOSTNAME): Don't define. + (HAVE_INET_ADDR): Likewise. + (lookup): Fixed typo. + (aton): Don't use `address' as name of local variable. + (lookup): Use HAVE_INET6, not AF_INET6. + + * configure: Rebuilt. + * configure.in: Look for functions inet_aton, inet_addr, + gethostname, inet_pton, uname. Check for sockaddr_in6 structure. + Check for socklen_t typedef. + + * exception.cc (__throw): Declare as __noreturn__. + +Mon Feb 22 15:27:35 1999 Per Bothner + + * Makefile.am, Makefile.in: Also build java/net. + (java/io/FileDescriptor.h): Add friend java::net::PlainSocketImpl. + + * java/io/natFile.cc: #define _POSIX_PTHREAD_SEMANTICS and _REENTRANT. + * java/util/natGregorianCalendar.cc: #define _REENTRANT. + + * prims.cc (_Jv_malloc, _Jv_Free): New functions. + * include/cni.h (JvMalloc, JvFree): New inline functions. + (JvThrow): Add __noreturn__ attribute. + * include/javaprims.h (_Jv_Malloc, _Jv_Free): New declarations. + (_Jv_Throw): Add __noreturn__ attribute. + + * java/net/PlainSocketImpl.java: Init fnum to -1. + * java/net/ServerSocket.java: Add missing throws clauses. + * java/lang/Socket.java: For the constructor taking a SocketImpl, + don't call create on the latter. Instead, other constructors + have to explicitly call SocketImpl.create. + * java/net/natPlainSocketImpl.cc (accept): Change variable addrlen + from size_t to int, to match ::accept prototype. + * java/net/natInetAddress.cc: Use JvFree rather than free. + + +1999-02-22 Tom Tromey + + * include/javaprims.h: Added new classes. + * java/text/StringCharacterIterator.java: New file. + * java/text/CharacterIterator.java: New file. + + * java/text/ParseException.java (errorOffset): Now private. + +Mon Feb 22 12:54:53 1999 Per Bothner + + * java/net: New package. + * java/net/{InetAddress.java,PlainSocketImpl.java,ServerSocket.java, + Socket.java,SocketException.java,SocketImpl.java, + SocketImplFactory.java,UnknownHostException.java,natInetAddress.cc, + natPlainSocketImpl.cc}: New classes. + + * configure.in (AC_CHECK_HEADERS): Also check for , + , and . + * include/config.h.in: Add place-holders for HAVE_ARPA_INET_H, + HAVE_NETDB_H, HAVE_NETINET_IN_H, and HAVE_SYS_SOCKET_H. + + * classes.pl: Translate package into "namespace", not "class". + * include/javaprims.h: Update class list, using "namespace". + +1999-02-21 Tom Tromey + + * java/util/natGregorianCalendar.cc (_POSIX_PTHREAD_SEMANTICS): + Define when appropriate. + +1999-02-20 Tom Tromey + + * java/lang/natString.cc (_Jv_GetStringUTFRegion): Encode \u007f + as a single byte and \u07ff as two bytes. + (_Jv_GetStringUTFLength): Likewise. + * include/jvm.h (UTF8_GET): Mask first byte of 3-byte encoding + with 0x0f, not 0x1f. + +1999-02-19 Tom Tromey + + * java/io/DataOutputStream.java (writeUTF): When encoding + character as 3 bytes, `or' first byte with 0xe0, not 0xc0. + * java/io/DataInputStream.java (readUTF): Mask second byte of + 3-byte character with 0x3f, not 0x1f. + + * java/io/DataInputStream.java (readLong): Cast result of + readUnsignedByte to long before using. + + * java/io/FileInputStream.java (finalize): Only finalize `fd' if + it is not null. + + * mauve-libjava: Re-enabled java.io.DataInputOutput. + * include/no-threads.h (_Jv_ThreadInterrupt): Removed name of + argument to avoid warning. + * include/quick-threads.h (_Jv_ThreadInterrupt): Removed name of + argument to avoid warning. + +1999-02-18 Tom Tromey + + * mauve-libjava: Omit java.io.DataInputOutput and + java.io.Utf8Encoding. + +1999-02-17 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added InterruptedIOException.h. + * java/io/natFileDescriptorPosix.cc: Include + InterruptedIOException.h, Thread.h. + (write): Throw InterruptedIOException when required. + (read): Likewise. + * posix-threads.cc: Include . + (_Jv_ThreadInterrupt): New function. + (INTR): New define. + (handle_intr): New function. + (_Jv_InitThreads): Register handle_intr via sigaction. + * java/lang/natThread.cc (interrupt): Call _Jv_ThreadInterrupt. + * include/posix-threads.h (_Jv_ThreadInterrupt): Declare. + * include/quick-threads.h (_Jv_ThreadInterrupt): New function. + * include/no-threads.h (_Jv_ThreadInterrupt): New function. + +1999-02-19 Andrew Haley + + * java/lang/ThreadGroup (setMaxPriority): Set the maximum priority + of subgroups. + (ThreadGroup (int)): Set the maximum priority of the initial + ThreadGroup. + +1999-02-18 Andrew Haley + + * java/lang/natClass.cc (forName): Check for the case where a + classname is the name of an array and call FindClassFromSignature + to find the Class. + +1999-02-18 Andrew Haley + + * java/lang/StringBuffer (insert (int, String)): Move up any + characters above the insert position and increase the length of + the string buffer by the length of the argument. + (insert (int, char[])): Likewise. + (insert (int, char)): Likewise. + (StringBuffer (String)): The initial capacity of the string buffer + is 16 plus the length of the argument. + (getChars): Add a JDK 1.2 FIXME. + +1999-02-18 Andrew Haley + + * java/lang/Short.java (parseShort(String, int)): Pass radix to + Integer.parseInt. + +1999-02-18 Andrew Haley + + * java/lang/Double.java (equals): Use a bit-by-bit comparision + instead of floating-point equality. This is necessary for + correct floating-point Hashtables. + * java/lang/Float.java (equals): Ditto. + +1999-02-16 Tom Tromey + + * java/util/Properties.java (list): Truncate value to 37 + characters and add "...". + +1999-02-16 Tom Tromey + + * java/util/Vector.java (Vector): Throw IllegalArgumentException + if initCap is negative. + (contains): Implement JDK1.2-style handling of null argument. + (removeElement): Likewise. + (indexOf): Likewise. Also, correctly handle case where idx is + negative. + (lastIndexOf): Likewise. + +1999-02-16 Tom Tromey + + * java/lang/natString.cc (init): Increment source pointer in + loop. + +1999-02-16 Tom Tromey + + * exception.cc: Include NullPointerException.h. + (_Jv_Throw): If `value' is NULL, throw a NullPointerException. + +1999-02-16 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (AUTOMAKE_OPTIONS): Added `no-installinfo. + +Sat Feb 13 20:25:09 1999 Bonzo Armstrong + + * configure.in: Don't undefine EH_COMMON_INCLUDE just because + we're compiling canadian. + * configure: Regenerated. + +1999-02-12 Andrew Haley + + * java/lang/sf_rint.c: Resurrected. This file shouldn't have been + deleted from libgcj. + +1999-02-12 Tom Tromey + + * exception.cc (_Jv_eh_alloc): Use _Jv_AllocBytes, not malloc. + (_Jv_eh_free): Don't call free. + Don't declare malloc or free. + +1999-02-11 Tom Tromey + + * configure.host: Use `libgcj', not `libjava'. Removed `echo'. + +1999-02-11 Andrew Haley + + * ef_fmod.c, sf_ceil.c, sf_fabs.c, sf_floor.c, sf_rint.c, + wf_fmod.c: Deleted. These are all files from fdlibm which aren't + needed by java.lang.*. + * Makefile.am: ef_fmod.o, sf_ceil.o, sf_fabs.o, sf_floor.o, sf_rint.o, + wf_fmod.o: Removed from libjava.a. + +1999-02-11 Tom Tromey + + * include/javaprims.h: Reverted previous change; with it + exception.cc can't compile. + + * include/javaprims.h (_Jv_Throw): Mark as noreturn. + + * include/config.h.in: Rebuilt. + * include/posix-threads.h (_Jv_ThreadYield): Conditionalize on + HAVE_SCHED_YIELD. + * configure: Rebuilt. + * configure.in: Check for sched_yield. Look in thread library for + all thread functions. + + * posix-threads.cc (_Jv_MutexInit): Handle case where system has + no recursive mutexes. + (_Jv_MutexDestroy): Define when required. + (_Jv_MutexLock): Likewise. + (_Jv_MutexUnlock): Likewise. + (_Jv_CondWait): Conditionalize on HAVE_RECURSIVE_MUTEX. + * include/posix-threads.h (HAVE_RECURSIVE_MUTEX): New define. + (_Jv_Mutex_t): New structure. + (_Jv_MutexDestroy): Only define if recursive mutexes available. + (_Jv_MutexLock): Likewise. + (_Jv_MutexUnlock): Likewise. + +1999-02-10 Tom Tromey + + * aclocal.m4, configure, Makefile.in: Rebuilt. + * acinclude.m4: Renamed libjava to libgcj. Updated to use + automake 1.4. + * configure.in: Changed to track library changes. + * Makefile.am (toollib_LIBRARIES): Renamed libjava to libgcj. + (AM_CXXFLAGS): Likewise. + (data_DATA): Likewise. + (AM_CFLAGS): Likewise. + (JC1FLAGS): Likewise. + (libgcj_a_SOURCES): Likewise. + (EXTRA_libgcj_a_SOURCES): Likewise. + (libgcj_a_DEPENDENCIES): Likewise. + (libgcj_a_LIBADD): Likewise. + (libgcj.zip): Likewise. + (CLEANFILES): Likewise. + ($(nat_headers)): Likewise. + (java/lang/FirstThread.h): Likewise. + (java/lang/ThreadGroup.h): Likewise. + (java/lang/String.h): Likewise. + (java/lang/reflect/Field.h): Likewise. + (BUILT_SOURCES): Likewise. + (maintainer-check): Likewise. + (CONFIG_STATUS_DEPENDENCIES): Likewise. +Tue Feb 9 11:06:38 1999 Anthony Green + + * java/util/natGregorianCalendar.cc (computeFields): Only use + gmtime_r and localtime_r when configured for posix threads. + + * java/io/natFile.cc (get_entry): Only use readdir_r when + configured for posix threads. + + * java/util/natGregorianCalendar.cc: Update copyright notice. + * java/util/TimeZone.java: Ditto. + * java/util/SimpleTimeZone.java: Ditto. + +1999-02-08 Tom Tromey + + * java/io/PrintStream.java (line_separator): New constant. + (print): Use line_separator, not `file.separator' property. + (println): Use line_separator. + + * java/lang/natClass.cc (newInstance): Throw IllegalAccessError + when trying to instantiate Class. + + * java/lang/ThreadGroup.java (ThreadGroup): Throw + NullPointerException if argument is null. + + * java/lang/Thread.java (setName): Throw NullPointerException, not + IllegalArgumentException. + (Thread): Likewise. + +1999-02-08 Andrew Haley + + * java/lang/natClass.cc (newInstance): Don't allow anyone to + create new Classes with Class.newInstance(). + + * java/lang/natClass.cc (_Jv_FindArrayClass): Only add a + semiciolon to end of an array Class's signature if the elements of + the array aren't themselves arrays. + + * java/lang/natSystem.cc (arraycopy): The size of an element of an + array of objects is always sizeof(jobject), not the size of the + object to which the reference points. + +1999-02-08 Tom Tromey + + * java/util/BitSet.java (and): Throw NullPointerException when + required. + (or): Likewise. + (xor): Likewise. + + * java/util/BitSet.java (BitSet): Throw NegativeArraySizeException + if argument is negative. + (clear): Correctly compute `offset'. Throw + IndexOutOfBoundsException when required. + (set): Likewise. + (get): Likewise. Also, return correct value. + (ensure): Changed meaning of argument. + (toString): Wrap contents in `{}'; put spaces after commas. + (hashCode): Don't try to examine elements off the end of array. + (or): Correctly include bits past the end of this bit set. + (xor): Likewise. + +Thu Feb 4 12:48:03 1999 Warren Levy + + * configure.host (mips-tx39-*): Use jmr3904dram.ld link script + instead of the jmr3904app.ld script (i.e. use DRAM instead of SRAM). + +1999-02-04 Andrew Haley + + * java/lang/natClass.cc (Class::forName): Remove code which mapped + '/' in signatures to '.' + (Class::getName): Likewise, + (_Jv_FindArrayClass): Add a semiciolon to end of an array Class's + signature. + * java/lang/natFirstThread.cc (run): Change '/' in main's + signature to '.'. + +1999-02-03 Andrew Haley + + * configure.host: -ffloat-store added when compiling libjava on + x86. fdlibm apparently relies on this. + + * java/lang/ThreadGroup.java (add): throw an exception if the + ThreadGroup has been destroyed. + + * java/lang/natMath.cc (round): Ensure correct NaN and overflow + behaviour. + +1999-01-27 Tom Tromey + + * java/lang/StringBuffer.java (StringBuffer): Handle null + argument. + +1999-01-21 Tom Tromey + + * java/lang/natFirstThread.cc (run): Don't require main to be + public. + +Wed Jan 20 15:44:56 1999 Anthony Green + + * boehm.cc (_Jv_InitGC): Clear out the free lists correctly. + +1999-01-20 Tom Tromey + + * java/lang/natString.cc (_Jv_StringFindSlot): Synchronize on + StringClass. + (rehash): Likewise. + (intern): Likewise. + (unintern): Likewise. + (_Jv_NewStringUtf8Const): Likewise. + + * java/text/SimpleDateFormat.java (format): Use [a-zA-z], not + Character.isLetter, to see if character is self-quoting. Also, + correctly handle quoted characters. + (parse): Fixed typo. Also now throws ParseException. + +1999-01-15 Tom Tromey + + * java/lang/natObject.cc (INIT_NEEDED): Added missing close paren. + + * java/lang/natObject.cc (INIT_NEEDED): Added cast in case where + _Jv_SyncInfo has `init' member. + + * include/quick-threads.h (_Jv_MutexUnlock): Return result of + coop_mutex_unlock. + + * java/lang/natObject.cc (_Jv_MonitorExit): Throw + IllegalMonitorStateException if unlock fails. + + * prims.cc (_Jv_NewPrimArray): Assume allocated memory is all + zero. + (_Jv_NewObjectArray): Likewise. + +1999-01-14 Tom Tromey + + * java/lang/Character.java (isJavaIdentifierPart): Allow + LETTER_NUMBER characters. + + * chartables.pl (process_char): Fixed error messages. + + * include/java-chartables.h: Rebuilt with UniData 2.1.8. + * chartables.pl: Updated comments. Changed detection of non-digit + numeric values (no longer miss \u00b2 and friends). + + * java/lang/Character.java (isJavaIdentifierPart): Recognize + currency symbols and connector punctuation. + (isIdentifierIgnorable): Make 7f-9f ignorable. + + * prims.cc (_Jv_NewObjectArray): Check for overflow. + (_Jv_NewPrimArray): Likewise. + (SIZE_T_MAX): New define. + + * java/lang/ClassLoader.java (system): Now private and final. + + * boehm.cc (_Jv_MarkObj): Handle case where object's class is + null. + + * configure: Rebuilt. + * configure.in (EH_COMMON_INCLUDE): Add -I for `../include' as + well. + * exception.cc: Include gansidecl.h. + +1999-01-14 Andrew Haley + + * java/lang/Math.java, java/lang/natMath.cc: min and max routines + corrected: they didn't treat -0.0 and NaNs correctly. + +Wed Jan 13 13:32:22 1999 Anthony Green + + * nogc.cc: Use calloc to zero out memory. + +1999-01-11 Tom Tromey + + * java/lang/natClass.cc (isInstance): Return false if this class + is primitive, not if class of `obj' is primitive. + (_Jv_IsInstanceOf): Rewrote to use Class.isInstance. + + * java/io/SequenceInputStream.java (close): Handle case where `in' + is already null. + + * java/text/DateFormat.java (format): New method. + + * mauve-libjava: Omit java.text.DateFormat. + +1999-01-08 Tom Tromey + + * posix-threads.cc (_Jv_ThreadInitData): Removed name of unused + argument. + * include/posix-threads.h (_Jv_CondNotify): Removed name of unused + argument. + (_Jv_CondNotifyAll): Likewise. + + * configure: Rebuilt. + * configure.in: Change --enable-source-compilation logic to work + correctly. + +1999-01-07 Andrew Haley + + * Makefile.am (AM_MAKEFLAGS): Remove RUNTEST, EXPECT, + and RUNTESTFLAGS from AM_MAKEFLAGS. + * configure.in: AM_RUNTESTFLAGS added. + * configure.host: AM_RUNTESTFLAGS added. + * Makefile.in, test/Makefile.in, testsuite/Makefile.in: rebuilt. + * configure: rebuilt. + * testsuite/Makefile.am: RUNTESTFLAGS set from AM_RUNTESTFLAGS. + + * testsuite/libjava.mauve/DejaGNUTestHarness.java (main): use of + argv[] made conditional because embedded targets may not have + argv[]. + * testsuite/libjava.mauve/DejaGNUTestHarness.java (main): + explanatory comments added in call to super. + + * testsuite/libjava.mauve/test.exp (test_mauve): Test for an + exception thrown in the test harness itself added. + * testsuite/libjava.mauve/test.exp (test_mauve_sim): New routine. + +Wed Jan 6 17:27:39 1999 Per Bothner + + * java/text/DateFormatSymbols.java (zoneStringsDefault): Make static. + +1999-01-06 Tom Tromey + + * java/io/natFile.cc (get_entry): New function. + (performList): Use get_entry. + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_READDIR_R): New define. + * configure: Rebuilt. + * configure.in: Look for readdir_r. + + * java/util/natGregorianCalendar.cc (computeFields): Fixed comment. + + * java/util/natDate.cc: Added copyright header. + +1999-01-05 Tom Tromey + + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_ACCESS, HAVE_STAT, HAVE_REALPATH, HAVE_MKDIR, + HAVE_REALPATH, HAVE_RMDIR, HAVE_UNLINK): New macros. + * configure: Rebuilt. + * configure.in: Check for access, stat, mkdir, rename, rmdir, + unlink, and realpath. + * java/io/natFile.cc (access): Conditionalize on HAVE_ACCESS. + (stat): Conditionalize on HAVE_STAT. + (attr): Likewise. + (getCanonicalPath): Conditionalize on HAVE_REALPATH. + (performMkdir): Conditionalize on HAVE_MKDIR. + (performRenameTo): Conditionalize on HAVE_RENAME. + (performDelete): Conditionalize on HAVE_RMDIR and HAVE_UNLINK. + + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_GMTIME_R, HAVE_LOCALTIME_R): New defines. + * configure: Rebuilt. + * configure.in: Check for gmtime_r and localtime_r. For cross + builds, assume they exist. + + * mauve-libjava: Include java.text.DateFormatSymbols again. + * java/text/DateFormatSymbols.java (setLocalPatternChars): Renamed + from setAmPmStrings. + + * mauve-libjava: Omit java.text.DateFormatSymbols. + +1999-01-04 Tom Tromey + + * java/io/PushbackReader.java: `off' already includes `numBytes'. + + * java/io/LineNumberReader.java (read): Decrement `count' in + loop. + + * java/io/BufferedWriter.java (write): Correctly determine when + incoming data would overrun buffer. Flush buffer if write causes + it to become full. + + * java/io/BufferedOutputStream.java (write): Increment `count' + after copying data into buffer. + + * java/io/FilterOutputStream.java (close): Call flush first. + + * java/io/PipedReader.java (read): If read causes `out' to catch + up with `in', then set `in' to -1. + + * java/io/LineNumberInputStream.java (read): If no bytes read, + return -1. If no bytes requested, return 0. + + * java/lang/StringBuffer.java (insert): If `str' is null, use + string "null". + +1998-12-30 Anthony Green + + * README: Removed. + * LIBJAVA_LICENSE, COPYING.LIB: Created. + +1998-12-23 Tom Tromey + + * java/io/PushbackInputStream.java (read): `off' already includes + `numBytes'. + +1998-12-17 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (GCJ_canadian): Include target_alias. + + * java/lang/natFirstThread.cc (run): Require main's class to be + public. + +1998-12-16 Tom Tromey + + * java/util/Locale.java (JAPAN): Language is `ja', not `jp'. + + * java/util/ResourceBundle.java (getBundle): Throw + NullPointerException if locale argument is null. + + * java/lang/natClass.cc (forName): Throw NullPointerException if + argument is null. + Include NullPointerException.h. + +1998-12-14 Tom Tromey + + * java/lang/Character.java (Character): Implement Comparable. + (compareTo): New methods. + + * java/util/Locale.java (CANADA, FRANCE, JAPAN): Now `final'. Use + correct country and language codes. + (UK, US): New constants. + (setDefault): Language codes are lower-case. + + * java/lang/natClass.cc (getDeclaredConstructor): New method. + (getDeclaredConstructors): Likewise. + (getDeclaredField): Likewise. + (getDeclaredFields): Likewise. + (getDeclaredMethod): Likewise. + (getDeclaredMethods): Likewise. + (getField): Likewise. + (getFields): Likewise. + (getMethod): Likewise. + (getMethods): Likewise. + * java/lang/Class.java: Declare new methods. + * java/lang/Class.h: Declare new methods. + + * java/lang/natString.cc: Removed `#pragma implementation'. + * include/cni.h (_Jv_GetStringChars): New function. + * Makefile.in: Rebuilt. + * Makefile.am (java/lang/String.h): Don't generate definition for + _Jv_GetStringChars. + + * java/lang/natString.cc: Added `#pragma implementation'. + + * Makefile.in: Rebuilt. + * Makefile.am (libjava.zip): Put build directory first in class + path to avoid bug in compiler. + +1998-12-14 Anthony Green + + * java/util/Locale.java: Add CANADA, FRANCE and JAPAN. + + * include/javaprims.h: Add EventObject, ListResourceBundle and + ResourceBundle. + +1998-12-13 Anthony Green + + * mauve-libjava: Run the ResourceBundle tests. + + * java/lang/natClass.cc (_Jv_FindClass): Don't fail when loader is + NULL. + +Sun Dec 13 18:11:21 1998 Per Bothner + + * configure.in, configure: Make --enable-gcj-classes and + --enable-source-compilation the default. (Nervously...) Yeah! + Based on a patch from Tom Tromey. + +1998-12-13 Tom Tromey + + * java/util/EventObject.java: New file. + * java/util/EventListener.java: New file. + + * include/javaprims.h: Updated class declarations. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added Constructor.h. + (java/lang/String.h): Don't inline String::length(). + * java/lang/Class.h (getConstructor, getConstructors): Declare. + * java/lang/Class.java (initializeClass, hackRunInitializers, + hackTrampoline): No need to mark `final'. + (getConstructor, getConstructors): Declare. + * java/lang/reflect/Field.java (equals): New method. + * java/lang/natClass.cc (getConstructor): New method. + (getConstructors): Likewise. + Include Method.h, Field.h, Constructor.h. + * java/lang/reflect/Constructor.java: New file. + * java/lang/reflect/Method.java (toString): No space before open + paren. + (equals): Simplified. + +1998-12-13 Anthony Green + + * java/util/ResourceBundle.java: New file. + * java/util/ListResourceBundle.java: New file. + +1998-12-12 Tom Tromey + + * java/lang/System.java (in, out, err): Now buffered streams by + default. + + * include/javaprims.h: Updated class declarations. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added AccessibleObject.h, Method.h, + InvocationTargetException.h, Void.h, Byte.h, Short.h, Integer.h, + Long.h, Boolean.h. + (nat_files): Added natMethod.o. + * java/lang/reflect/natMethod.cc: New file. + * java/lang/reflect/Field.java (Field): Now extends + AccessibleObject. + * java/lang/reflect/AccessibleObject.java: New file. + * java/lang/reflect/InvocationTargetException.java: New file. + +1998-12-11 Tom Tromey + + * boehm.cc, prims.cc, include/jvm.h, java/lang/Class.h, + java/lang/Object.h, java/lang/natClass.cc, java/lang/natObject.cc: + Renamed dtable -> vtable and _Jv_DispatchTable -> _Jv_VTable. + + * java/io/OutputStreamWriter.java (buffer): Size at 8192 bytes. + +1998-12-09 Tom Tromey + + * java/util/natDate.cc (_POSIX_THREAD_SEMANTICS): Define if + HAVE_CTIME_R. + + * java/lang/natCharacter.cc (toTitleCase): Handle case where + character is already titlecase. + + * java/lang/Character.java (isJavaLetter): Follow spec. + (isJavaLetterOrDigit): Likewise. + + * java/util/GregorianCalendar.java (gregorianCutover): Append + `L'. + + * java/lang/Character.java (isWhitespace): Use \r and not \u000d. + +1998-12-08 Tom Tromey + + * java/lang/reflect/Modifier.java (toString): Replace second + `static' with `synchronized'. + + * java/lang/natObject.cc (_Jv_FinalizeObject): Call hack12_6. + * java/lang/Object.h (Object::hack12_6): Declare. + * java/lang/Object.java (hack12_6): New function. + +1998-12-07 Tom Tromey + + * include/java-array.h (__JArray::clone): Removed decl. + * prims.cc (__JArray::clone): Removed. + * java/lang/natObject.cc (clone): Incorporate code to clone an + array. + + * java/lang/natClass.cc (_Jv_NewClass): Set class loader. + (_Jv_FindArrayClass): Set dtable_method_count on new class. + Correctly use dtable_method_count. + +1998-12-07 Andrew Haley + + * java/lang/Double.java (isInfinite, isNaN): Handle correct + IEEE754 values. + +1998-12-06 Anthony Green + + * mauve-libjava: Don't test ResourceBundle. + +1998-12-04 Tom Tromey + + More JDK 1.2 spec fixes: + * java/util/Date.java (millis): Now private. + * java/text/DateFormat.java (DateFormat): Constructor now + protected. + * java/lang/Void.java (Void): New private constructor. + * java/lang/System.java (System): New private constructor. + * java/lang/SecurityManager.java (classLoaderDepth): Uncommented + body. + (currentClassLoader): New method. + (currentLoadedClass): New method. + * java/lang/Math.java (Math): New private constructor. + * java/lang/Compiler.java (Compiler): New private constructor. + * java/lang/Class.java (Class): New private constructor. + * java/lang/Double.java (toString): Removed access specifier from + two-argument `toString' method. + +1998-12-04 Andrew Haley + + * java/lang/s_rint.c (rint): Make the variable w volatile; this + causes it to be flushed from an fp register (where it may be + longer than double precision) to a double in memory. This is + essential to ensure correct rounding behaviour. + +1998-12-04 Tom Tromey + + * include/java-assert.h (_Jv_Abort): Declare as `noreturn' + function. + + * java/lang/Character.java (isIdentifierIgnorable): Added comment + explaining apparent divergence from JDK 1.2. + +1998-12-04 Per Bothner + + * include/no-threads.h: Remove unused parameter names. + This silences a bunch of warnings. + +1998-12-04 Tom Tromey + + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_CTIME_R): New symbol. + +1998-12-03 Tom Tromey + + * mauve-libjava: Added many more categories to reject. + + Changes to follow JDK1.2 spec: + * java/lang/System.java (arraycopy, init_properties, checkSetIO, + setErr, setIn, setOut): No need to be `final'. + * java/lang/natObject.cc (wait): `nanos' argument is an int. + * java/lang/Object.h (Object::wait): `nanos' argument is an int. + * java/lang/Object.java (wait): `nanos' argument is an int. + * java/lang/VirtualMachineError.java: Class is abstract. + * java/lang/ThreadDeath.java: Made constructors public. + * java/io/FileDescriptor.java (FileDescriptor): Added missing + constructor. + +Thu Dec 3 20:29:38 1998 Warren Levy + + * java/text/DateFormatSymbols.java (getAmPmStrings, + getLocalPatternChars, setShortWeekdays): Fixed typos in method names. + +Thu Dec 3 19:21:53 1998 Warren Levy + + * java/io/RandomAccessFile.java (writeInt, writeLong, writeFloat, + writeDouble, writeByte, writeBytes, writeChar, writeChars, + writeShort, writeUTF): Added 'final' to signature to match JDK 1.1 + and 1.2. + + * java/lang/IllegalThreadStateException.java + (IllegalThreadStateException): Changed extending class to match spec. + + * java/lang/NumberFormatException.java + (java/lang/NumberFormatException): Changed extending class to match + spec. + + * java/util/Observer.java (Observer): Changed sig to match JCL. + +Thu Dec 3 19:05:26 1998 Warren Levy + + * java/io/DataOutputStream.java (writeInt, writeLong, writeFloat, + writeDouble, writeBytes, writeChars, writeUTF): Added 'final' to + signature to match JDK 1.1 and 1.2. + +Thu Dec 3 16:47:42 1998 Warren Levy + + * Makefile.am: Changed to use $(PERL) rather than hardcoded 'perl'. + * configure.in (PERL): Added AC_CHECK_PROGS to look for installed perl. + * Makefile.in, configure: Rebuilt. + + * java/text/ParsePosition.java (setErrorIndex): Fixed typo in method + name. + +1998-12-02 Tom Tromey + + * mauve-libjava: New file. + + The remaining `-W -Wall' fixes: + * java/lang/e_sqrt.c (__ieee754_sqrt): Added cast to unsigned to + avoid warning. + * java/lang/s_scalbn.c (scalbn): Added braces to avoid ambiguous + `else'. + * java/lang/s_floor.c (floor): Added cast to unsigned to avoid + warning. + * java/lang/e_pow.c (__ieee754_pow): Added cast to unsigned to + avoid warning. + * java/lang/e_log.c (__ieee754_log): Added braces to avoid + ambiguous `else'. + * java/lang/s_ceil.c (ceil): Cast `i1' to unsigned to avoid + warning. + * java/lang/e_atan2.c (__ieee754_atan2): Added parentheses per gcc + suggestion. + * java/lang/strtod.c (_strtod_r): Added parentheses per gcc + suggestion. + * java/lang/mprec.c (Balloc): Removed unused variable. + (mult): Added parentheses per gcc suggestion. + (pow5mult): Likewise. + (lshift): Likewise. + (ulp): Likewise. + (b2d): Likewise. + (d2b): Likewise. + * java/lang/dtoa.c (_dtoa_r): Added some parentheses per gcc + suggestion. Added cast to `int' to avoid signed/unsigned + comparison. + * jni.cc (_Jv_JNI_GetSuperclass): Removed name of unused + parameter. + (IsAssignableFrom): Likewise. + (_Jv_JNI_GetObjectField): Likewise. + (_Jv_JNI_GetByteField): Likewise. + (_Jv_JNI_GetShortField): Likewise. + (_Jv_JNI_GetIntField): Likewise. + (_Jv_JNI_GetLongField): Likewise. + (_Jv_JNI_GetStringLength): Likewise. + (_Jv_JNI_ToReflectedField): Likewise. + (_Jv_JNI_FromReflectedField): Likewise. + (_Jv_JNIFunctions): Uncommented IsAssignableFrom. + + * Makefile.in: Rebuilt. + * Makefile.am (AM_CFLAGS): Define conditionally. + (WARNINGS): New macro. + (AM_CXXFLAGS): Include WARNINGS. + * configure: Rebuilt. + * configure.in (USING_GCC): New conditional. + + * prims.cc (_Jv_Abort): Declare twice, to avoid warnings. + + * java/lang/Character.java: Changed classification constants to + type `byte' to match JDK 1.2 docs. + +1998-12-01 Tom Tromey + + Some fixes to be `-W -Wall' clean: + * boehm.cc (_Jv_MarkObj): Removed name of unused parameter. + (_Jv_MarkArray): Likewise. + * java/lang/natCharacter.cc (to_lower_title): `i' is unsigned. + (to_upper_title): Likewise. + (isTitleCase): Likewise. + (toTitleCase): Likewise. + (getNumericValue): Likewise. + (isLowerCase): Likewise. + * java/lang/natString.cc (charAt): Don't cast `i' to unsigned + (avoids compiler warning). + * java/lang/natClass.cc (getDeclaredClasses): Always return a + value. + (getDeclaringClass): Likewise. + (_Jv_LookupInterfaceMethod): Likewise. + (_Jv_NewClass): Removed name of unused parameter. + * exception.cc (_Jv_type_matcher): Removed unused variable. + (_Jv_setup_eh_info): Removed name of unused parameter. + * prims.cc (_Jv_NewArray): Always return a value. + (_Jv_FindClassFromSignature): Likewise. + * include/java-field.h (getNameUtf8Const): Removed name of unused + parameter. + * include/quick-threads.h (_Jv_ThreadInitData): Removed name of + unused parameter. + (_Jv_ThreadSetPriority): Likewise. + + * java/lang/natString.cc (hashChars): Now static. + + * java/lang/FirstThread.java (FirstThread): Now final. + + * java/io/File.java (performMkdir, performRenameTo): Now private. + + * java/lang/natSystem.cc (currentTimeMillis): Return a value even + if no time function defined. + + * configure: Rebuilt. + * configure.in: Look for ctime_r, ctime. + * java/util/Date.java (toString): Now native. + * java/util/natDate.cc (toString): Rewrote. + +1998-11-27 Andrew Haley + + * Add LDFLAGS line to allow TX39 test cases to link when cross + compiling. + +1998-11-23 Anthony Green + + * boehm.cc, chartables.pl, classes.pl, exception.cc, jni.cc, + no-threads.cc, nogc.cc, posix-threads.cc, prims.cc, + quick-threads.cc, include/boehm-gc.h, include/cni.h, + include/java-array.h, include/java-assert.h, include/java-field.h, + include/javaprims.h, include/jni.h, include/jvm.h, + include/no-gc.h, include/no-threads.h, include/posix-threads.h, + include/quick-threads.h, java/io/BufferedInputStream.java, + java/io/BufferedOutputStream.java, java/io/BufferedReader.java, + java/io/BufferedWriter.java, java/io/ByteArrayInputStream.java, + java/io/ByteArrayOutputStream.java, java/io/CharArrayReader.java, + java/io/CharArrayWriter.java, + java/io/CharConversionException.java, java/io/DataInput.java, + java/io/DataInputStream.java, java/io/DataOutput.java, + java/io/DataOutputStream.java, java/io/EOFException.java, + java/io/File.java, java/io/FileDescriptor.java, + java/io/FileInputStream.java, java/io/FileNotFoundException.java, + java/io/FileOutputStream.java, java/io/FileReader.java, + java/io/FileWriter.java, java/io/FilenameFilter.java, + java/io/FilterInputStream.java, java/io/FilterOutputStream.java, + java/io/FilterReader.java, java/io/FilterWriter.java, + java/io/IOException.java, java/io/InputStream.java, + java/io/InputStreamReader.java, + java/io/InterruptedIOException.java, + java/io/LineNumberInputStream.java, java/io/LineNumberReader.java, + java/io/OutputStream.java, java/io/OutputStreamWriter.java, + java/io/PipedInputStream.java, java/io/PipedOutputStream.java, + java/io/PipedReader.java, java/io/PipedWriter.java, + java/io/PrintStream.java, java/io/PrintWriter.java, + java/io/PushbackInputStream.java, java/io/PushbackReader.java, + java/io/RandomAccessFile.java, java/io/Reader.java, + java/io/SequenceInputStream.java, java/io/Serializable.java, + java/io/StreamTokenizer.java, + java/io/StringBufferInputStream.java, java/io/StringReader.java, + java/io/StringWriter.java, java/io/SyncFailedException.java, + java/io/UTFDataFormatException.java, + java/io/UnsupportedEncodingException.java, java/io/Writer.java, + java/io/natFile.cc, java/io/natFileDescriptorEcos.cc, + java/io/natFileDescriptorPosix.cc, + java/lang/AbstractMethodError.java, + java/lang/ArithmeticException.java, + java/lang/ArrayIndexOutOfBoundsException.java, + java/lang/ArrayStoreException.java, java/lang/Boolean.java, + java/lang/Byte.java, java/lang/Character.java, java/lang/Class.h, + java/lang/Class.java, java/lang/ClassCastException.java, + java/lang/ClassCircularityError.java, + java/lang/ClassFormatError.java, java/lang/ClassLoader.java, + java/lang/ClassNotFoundException.java, + java/lang/CloneNotSupportedException.java, + java/lang/Cloneable.java, java/lang/Comparable.java, + java/lang/Compiler.java, java/lang/Double.java, + java/lang/Error.java, java/lang/Exception.java, + java/lang/ExceptionInInitializerError.java, + java/lang/FirstThread.java, java/lang/Float.java, + java/lang/IllegalAccessError.java, + java/lang/IllegalAccessException.java, + java/lang/IllegalArgumentException.java, + java/lang/IllegalMonitorStateException.java, + java/lang/IllegalStateException.java, + java/lang/IllegalThreadStateException.java, + java/lang/IncompatibleClassChangeError.java, + java/lang/IndexOutOfBoundsException.java, + java/lang/InstantiationError.java, + java/lang/InstantiationException.java, java/lang/Integer.java, + java/lang/InternalError.java, java/lang/InterruptedException.java, + java/lang/LinkageError.java, java/lang/Long.java, + java/lang/Math.java, java/lang/NegativeArraySizeException.java, + java/lang/NoClassDefFoundError.java, + java/lang/NoSuchFieldError.java, + java/lang/NoSuchFieldException.java, + java/lang/NoSuchMethodError.java, + java/lang/NoSuchMethodException.java, + java/lang/NullPointerException.java, java/lang/Number.java, + java/lang/NumberFormatException.java, java/lang/Object.h, + java/lang/Object.java, java/lang/OutOfMemoryError.java, + java/lang/Process.java, java/lang/Runnable.java, + java/lang/Runtime.java, java/lang/RuntimeException.java, + java/lang/SecurityException.java, java/lang/SecurityManager.java, + java/lang/Short.java, java/lang/StackOverflowError.java, + java/lang/String.java, java/lang/StringBuffer.java, + java/lang/StringIndexOutOfBoundsException.java, + java/lang/System.java, java/lang/Thread.java, + java/lang/ThreadDeath.java, java/lang/ThreadGroup.java, + java/lang/Throwable.java, java/lang/UnknownError.java, + java/lang/UnsatisfiedLinkError.java, + java/lang/UnsupportedOperationException.java, + java/lang/VerifyError.java, java/lang/VirtualMachineError.java, + java/lang/Void.java, java/lang/natCharacter.cc, + java/lang/natClass.cc, java/lang/natDouble.cc, + java/lang/natFirstThread.cc, java/lang/natFloat.cc, + java/lang/natMath.cc, java/lang/natObject.cc, + java/lang/natRuntime.cc, java/lang/natString.cc, + java/lang/natSystem.cc, java/lang/natThread.cc, + java/lang/reflect/Field.java, java/lang/reflect/Member.java, + java/lang/reflect/Modifier.java, java/lang/reflect/natField.cc, + java/text/DateFormat.java, java/text/DateFormatSymbols.java, + java/text/FieldPosition.java, java/text/Format.java, + java/text/NumberFormat.java, java/text/ParseException.java, + java/text/ParsePosition.java, java/text/SimpleDateFormat.java, + java/util/BitSet.java, java/util/Calendar.java, + java/util/ConcurrentModificationException.java, + java/util/Date.java, java/util/Dictionary.java, + java/util/EmptyStackException.java, java/util/Enumeration.java, + java/util/GregorianCalendar.java, java/util/Hashtable.java, + java/util/Locale.java, java/util/MissingResourceException.java, + java/util/NoSuchElementException.java, java/util/Observable.java, + java/util/Observer.java, java/util/Properties.java, + java/util/Random.java, java/util/SimpleTimeZone.java, + java/util/Stack.java, java/util/StringTokenizer.java, + java/util/TimeZone.java, java/util/TooManyListenersException.java, + java/util/Vector.java, java/util/natGregorianCalendar.cc: Updated + copyright notices. + + * exception.cc: Include eh-common.h instead of duplicating + code. + +1998-11-23 Tom Tromey + + * configure.host: Don't add `-O2' to libjava_flags. Only add + `-Os' to libjava_flags once. + +1998-11-17 Andrew Haley + + * Makefile.am: add LIBJAVA_JAVAFLAGS. + * Makefile.in: likewise + * acconfig.h: add ECOS conditional for configure.h + * config.h.in: likewise + * configure: add test for --with-ecos + * configure.in: likewise + * java/io/natFileDescriptorEcos.cc (java::io::FileDescriptor::write): + rename call to avoid name clash. + * java/lang/natSystem.cc: add eCos clock support. + * java/util/natGregorianCalendar.cc: add eCos support. + +1998-11-20 Andrew Haley + + * Makefile.am, Makefile.in, configure.host: tx39 build option + "-G 0" added. + +Wed Nov 18 18:55:25 1998 Warren Levy + + * java/io/BufferedReader.java: Added more comments for clarity. + (mark): Used more mnemonic name for local var extraBuffSpace. + + * java/io/LineNumberReader.java (lineEnd): Removed method to avoid + confusion with private method of same name in superclass. + (skipRedundantLF): Set fields in special case to avoid infinite + recursion. Check if markPos has been invalidated in special case. + (readLine): Rewritten to use readLine method of superclass. + (skip): Incorporated code from lineEnd. + +Wed Nov 18 02:46:03 1998 Warren Levy + + * java/io/BufferedReader.java (readLine): New method. + (lineEnd): new private method. + (mark): Track special case for readLine of getting '\r' at the + end of the buffer. + (reset): Ditto. + (read): Ditto. + (fill): Ditto. + (skip): Ditto. + + * java/io/InputStreamReader.java (read): Return number chars skipped + rather than requested. + + * java/lang/StringBuffer.java (append): Update count and differentiate + between field and local variable. + + * java/util/Date.java (parseTz): Evaluate in minutes rather than + seconds. Deal with military style time. + (parse): Consistently treat all timezones in minutes until final + calculation. Flag as non-local timezone. Return value in milliseconds. + (setTime): Adjust for year offset from 1900. + (UTC): Adjust for year offset from 1900. + +1998-11-17 Tom Tromey + + * configure: Rebuilt. + * configure.in: Switch on host, not target. + + * Makefile.in: Rebuilt. + * Makefile.am (GCJ_no): New macro. + (GCJ): Use @CANADIAN@. + (GCJH_no): New macro + (GCJH_canadian): New macro. + (GCJH): Use @CANADIAN@. + (ZIP_no): New macro. + (ZIP_canadian): New macro. + (ZIP): Use @CANADIAN@. + * aclocal.m4, configure: Rebuilt. + * configure.in (CANADIAN): Compute and subst. + +Tue Nov 17 12:44:37 1998 Anthony Green + + * java/io/FileDescriptor.java (finalize): Only close file + descriptor if valid. + +1998-11-17 Tom Tromey + + * prims.cc (_Jv_InitRuntime): Removed. + +1998-11-16 Tom Tromey + + * java/io/FileOutputStream.java (close): Only close file + descriptor if valid. + (finalize): New method. + + * prims.cc (_Jv_NewObjectArray): Set vtbl last. + (_Jv_NewPrimArray): Likewise. + * boehm.cc (_Jv_RegisterFinalizer): Use + GC_REGISTER_FINALIZER_NO_ORDER. + (GC_GENERIC_MALLOC): New define. + (_Jv_AllocObj): Use it. + (_Jv_AllocArray): Likewise. + (_Jv_AllocBytes): Likewise. + (_Jv_MarkObj): Just return if vtbl not set. + (_Jv_MarkArray): Likewise. + (MAYBE_MARK): New macro; use everywhere. + (_Jv_MarkObj): Mark fields belonging to superclasses as well. + +Mon Nov 16 14:57:53 1998 Warren Levy + + * java/util/natGregorianCalendar.cc (computeTime): Cast a time_t + to a jlong before calculation to prevent overflow. + +1998-11-16 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Fixed typo. + +1998-11-15 Tom Tromey + + * java/lang/Class.h (Class::getName): Removed definition. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added InstantiationException.h, + NoSuchMethodException.h. + * java/lang/natClass.cc (clinit_name): Renamed from init_name. + (init_name): New global. + (hackRunInitializers): Use clinit_name. + Include InstantiationException.h, NoSuchMethodException.h. + (newInstance): Do some error checking (but not all). Call + constructor. + (forName): Throw exception if class not found. + (getName): New method. + (forName): Transform class name from external format to internal + format before lookup. + +1998-11-15 Anthony Green + + * java/lang/Class.h (Class::forName): Method is static. + + * java/lang/natClass.cc (newInstance): Add simple implementation. + (forName): Ditto. + +Sat Nov 14 18:25:13 1998 Per Bothner + + * java/lang/Class.h (Class::accflags): Must be unsigned short (not + int), for compatibility with jc1. + +1998-11-14 Tom Tromey + + * include/config.h.in: Rebuilt. + * acconfig.h (LINUX_THREADS): New define. + * configure: Rebuilt. + * configure.in: Define LINUX_THREADS if using POSIX threads on + Linux. Look for pthread_mutexattr_setkind_np function. + * posix-threads.cc (throw_cleanup): New function. + (really_start): Push cleanup function. + (_Jv_ThreadCancel): New function. + (daemon_mutex, daemon_cond, non_daemon_count): New globals. + (_Jv_ThreadInitData): Set `exception' field in new structure. + (_Jv_ThreadStart): Increment non_daemon_count if not a daemon + thread. + (_Jv_ThreadWait): New function. + (_Jv_InitThreads): Initialize daemon globals. + (FLAG_DAEMON): New macro. + (really_start): Notify daemon_cond when non-daemon thread exits. + Include . + (struct starter): `object' field now a thread. + (_Jv_MutexInit): Use pthread_mutexattr_setkind_np if it exists. + * include/posix-threads.h (_Jv_CondInit): Use `0', not NULL. + (_Jv_ThreadWait): Removed definition. + (_Jv_Thread_t): Added `exception' field. + (_Jv_ThreadCancel): Removed definition. + +1998-11-13 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (libjava.zip): Compute javac before changing + directory. + + * Makefile.in: Rebuilt. + * Makefile.am (libjava.zip): Include directory entries. + + * Makefile.in: Rebuilt. + * Makefile.am (expanded): New macro. + (GCJ): Use it. + +1998-11-12 Tom Tromey + + * prims.cc (clone): New function. + * include/java-array.h (__JArray::clone): Removed definition. + + * java/lang/natObject.cc (clone): Don't assert that class is not + an array; array's `clone' method just calls this one. + + * Makefile.in: Rebuilt. + * Makefile.am (libjava.zip): Renamed target from classes.stamp. + Now creates zip file. Changed all users. + (ZIP): New macro. + (data_DATA): New macro. + +1998-11-11 Tom Tromey + + * configure: Rebuilt. + * configure.in: Recognize --enable-java-gc, not --enable-gc. + +Wed Nov 11 18:13:46 1998 Warren Levy + + * java/io/InputStream.java (reset): Add msg to thrown exception. + +Wed Nov 11 17:57:02 1998 Warren Levy + + * java/io/LineNumberInputStream.java: Rewritten. + + * java/io/StringBufferInputStream.java: Removed extraneous import. + +Wed Nov 11 15:19:33 1998 Warren Levy + + * java/io/StringBufferInputStream.java: Rewritten. + + * java/util/Date.java (parseMonth): Optimize. + (parseDayOfWeek): Created. + (parse): Optimize to use parseDayOfWeek. + +1998-11-11 Tom Tromey + + * java/lang/StringBuffer.java (append): Handle case where STR is + `null'. + + * include/javaprims.h: Regenerated class declarations. + + * configure: Rebuilt. + * configure.in: Added --enable-gcj-classes, + --enable-single-compilation, --enable-source-compilation flags. + * Makefile.in: Rebuilt. + * Makefile.am (java_io_files): New macro. + (java_lang_files): Likewise. + (java_text_files): Likewise. + (java_util_files): Likewise. + (java_files): Use new macros. + (java-io.o): New target. + (java-lang.o): Likewise. + (java-text.o): Likewise. + (java-util.o): Likewise. + (src_io_files): New macro. + (src_lang_files): Likewise. + (src_text_files): Likewise. + (src_util_files): Likewise. + (class_io_files): New macro. + (class_lang_files): Likewise. + (class_text_files): Likewise. + (class_util_files): Likewise. + (class_files): Use new macros. + (javao_files): Define conditionally. + (.java.o): New target. + ($(javao_files)): New target. + (GCJ): new macro. + (GCJH): Added $(EXEEXT). + (CLASSPATH_ENV): Removed. + (GCJCOMPILE): New macro. + +Wed Nov 11 12:03:15 1998 Warren Levy + + * java/util/Date.java (parse): Written from scratch. + +1998-11-11 Tom Tromey + + * java/lang/Throwable.java (toString): Correct sense of test for + determining when to include detail message in result. + + * java/lang/ThreadDeath.java (ThreadDeath): Added missing + constructor. + +Fri Nov 6 16:30:20 1998 Tom Tromey + + * java/lang/Class.h: Use _Jv_RegisterClasses, not + _Jv_RegisterClass. + * java/lang/natClass.cc (_Jv_RegisterClasses): New function. + (_Jv_RegisterClass): Use it. + * include/jvm.h (_Jv_RegisterClasses): Declare. + * java/lang/natObject.cc (init): Removed. + (sync_init): Never call _Jv_InitializeSyncMutex. + (_Jv_InitializeSyncMutex): Don't set `init'. + * prims.cc (JvRunMain): Don't run init functions. + +Thu Nov 5 17:14:37 1998 Tom Tromey + + * java/lang/natClass.cc (initializeClass): Set state before + resolving constants. + + * java/lang/natClass.cc (STATE_CONST_INIT): Removed. + (STATE_RESOLVED): New macro. + (initializeClass): Call resolveConstants. + (hackRunInitializers): Don't call resolveConstants. + (_Jv_FindArrayClass): Move short-circuit return for primitive + element types earlier in function. + +1998-11-03 Tom Tromey + + * prims.cc (no_memory): New global. + (_Jv_makeUtf8Const): Throw no_memory. + (_Jv_AllocObject): Likewise. + (_Jv_NewObjectArray): Likewise. + (_Jv_NewPrimArray): Likewise. + (JvRunMain): Initialize no_memory. + +Tue Nov 3 17:15:45 1998 Warren Levy + + * java/io/FileInputStream.java: Corrected date comment. + * java/io/SequenceInputStream.java: Rewritten. + +Mon Nov 2 17:20:31 1998 Tom Tromey (tromey@cygnus.com) + + * java/lang/FirstThread.java (die): New method. + * java/lang/natFirstThread.cc (die): Removed. + (DIE): New macro. + (run): Use `DIE', not `die'. + +Mon Nov 2 16:23:41 1998 Warren Levy + + * java/io/CharArrayReader.java (read): Move check into synchronized + block to prevent a close while in progress. + (reset): Ditto. + (skip): Ditto. + * java/io/PushbackReader.java (read): Ditto. + (ready): Ditto. + (unread): Ditto. + * java/io/StringReader.java (mark): Ditto. + (read): Ditto. + (reset): Ditto. + (skip): Ditto. + +Mon Nov 2 15:56:20 1998 Warren Levy + + * java/io/PipedInputStream.java: Updated status. + (connect): Added code to prevent infinite recursion and to + differentiate exception causes. + (read): Added code to differentiate exception causes. + (receive): Made exception pass string with the cause. + + * java/io/PipedOutputStream.java: Updated status. + (connect): Added code to call connect at the other end of the pipe. + +Mon Nov 2 00:22:12 1998 Warren Levy + + * java/io/PipedInputStream.java (connect): Throw exception if + already connected to the same output stream. + (read): Do bounds checking first. + +Sun Nov 1 22:48:55 1998 Warren Levy + + * java/io/PipedInputStream.java: Added private boolean outClosed. + (available): Removed check if output stream is open. + (close): Mark the buffer as empty so available returns 0. + (read): Check if the output stream was closed and then return EOF + when the buffer is empty. + (receive): Mark the output stream as closed when passed a -1. + + * java/io/PipedOutputStream.java (close): Notify the input stream + that there's no more data coming. + (connect): Added a FIXME comment to note more coordination needed + with PipedInputStream. + (flush): Added a FIXME comment to mark what this method might do + instead of nothing. + +Fri Oct 30 14:27:21 1998 Warren Levy + + * java/io/PipedInputStream.java: Rewritten. + +1998-10-30 Tom Tromey + + * java/lang/Throwable.java: Rewrote from scratch. + + * java/lang/Class.h (Class): Don't mention newMultiArray. + * prims.cc (newMultiArray): Removed. + (_Jv_NewMultiArray): Removed. + (newArray): Removed. + (new_multi_array): New function. + (_Jv_NewMultiArray): Rewrote from scratch. + + * include/javaprims.h: Regenerated class declarations. + * classes.pl (scan): Don't declare PrimClass. + * include/cni.h (JvPrimClass): Use new names for classes. + * java/lang/Class.h (Class): Removed _Jv_initPrimClass as friend; + added _Jv_PrimClass. + * prims.cc (_Jv_PrimClass): Renamed from PrimClass. + (_Jv_initPrimClass): Removed. + (DECLARE_PRIM_TYPE): Generated globals now start with `_Jv_'. + (_Jv_AllocObject): Added comment. + (_Jv_NewObjectArray): Likewise. + (_Jv_NewPrimArray): Likewise. + +1998-10-29 Tom Tromey + + * java/lang/natClass.cc (_Jv_NewClass): Initialize new field. + (_Jv_FindArrayClass): Use dtable_method_count to compute size of + new dtable. + * java/lang/Class.h (Class): Added `dtable_method_count' field. + + * java/lang/natObject.cc (init): New global. + (sync_init): Call _Jv_InitializeSyncMutex if required. + + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added ClassLoader.h. + * include/jvm.h (_Jv_FindClassFromSignature): Declare. + * java/lang/Class.h (Class): simpleLookupClass, insertClass, + internalAddClass, lookupArray no longer friends. + _Jv_RegisterClass, _Jv_FindClassInCache, _Jv_NewClass, + _Jv_FindArrayClass now friends. + * java/lang/natClass.cc (HASH_LEN): New macro. + (HASH_UTF): Likewise. + (loaded_classes): New global. + (_Jv_FindClass): New function. + (ClassClass): New define. + (_Jv_FindClassInCache): New function. + (_Jv_RegisterClass): Likewise. + (_Jv_NewClass): Likewise. + Include + (ObjectClass): New define. + (CloneableClass): New define. + * prims.cc (_Jv_FindClass): Removed. + (simpleLookupClass): Removed. + (insertClass): Removed. + (CLASSHASHSZ): Removed. + (classPool): Removed. + (_Jv_RegisterClass): Removed. + (internalAddClass): Removed. + (ClassClass): Removed. + (RuntimeClass): Removed. + (lookupArray): Removed. + (CloneableClass): Removed. + (CLASSMAXSIG): Removed. + Rearranged file to group related functions together. + (_Jv_IsInstanceOf): Moved to natClass.cc. + (abort_final): Removed. + Removed some unused includes. + (classFromSig): Removed. + (_Jv_FindClassFromSignature): New function. + (_Jv_initPrimClass): Renamed. + (getClass): Removed. + +Thu Oct 29 23:17:17 1998 Warren Levy + + * java/io/FileDescriptor.java (finalize): Throws IOException + instead of Throwable. + + * java/io/FileInputStream.java: Rewritten. + + * java/io/StreamTokenizer.java (nextToken): Unread newline character + at the end of a comment. + +1998-10-29 Tom Tromey + + * include/javaprims.h: Regenerated class declarations. + * classes.pl (scan): Don't special-case ClassLoader. + + * prims.cc (processClass): Removed. + (_Jv_InitClass): Removed. + Removed all CSTATE_ macros. + (resolveConstants): Removed. + (MAXDIMS): Removed. + (_Jv_NewMultiArray): Cleaned up. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added NoClassDefFoundError.h. + * java/lang/Class.h (Class): Declare new methods. processClass no + longer a friend. + * java/lang/Class.java (hackTrampoline): New method. + (initializeClass): Declare. + (hackRunInitializers): Declare. + * java/lang/natClass.cc (getClassLoader): Moved into Class.h. + (initializeClass): New method. + (hackRunInitializers): New method. + (init_name, void_signature): Moved from prims.cc. + (_Jv_InitClass): New function. + (isAssignableFrom): Don't call processClass. + (STATE_NOTHING): New macro. + (resolveConstants): New function. + Include Thread.h. + (ErrorClass): New define. + + * java/lang/Class.java (getClassLoader): Declare. + * java/lang/ClassLoader.java: Rewrote from scratch. + + * java/lang/natClass.cc: Include IncompatibleClassChangeError.h, + AbstractMethodError.h, IllegalAccessError.h, + NoClassDefFoundError.h. + * include/jvm.h (StringClass): Declare _Jv_equalUtf8Consts. + * prims.cc (_Jv_equalUtf8Consts): Renamed from equalUtf8Consts; no + longer static. Changed return type. + * java/lang/natFirstThread.cc (run): Use _Jv_GetMethodLocal. + * java/lang/Class.h (Class): findMethodLocal no longer a friend. + * prims.cc (findMethodLocal): Removed. + (processClass): Use _Jv_GetMethodLocal. + +1998-10-28 Tom Tromey + + * prims.cc (_Jv_LookupInterfaceMethod): Removed. + * java/lang/Class.h (Class): Declare _Jv_GetMethodLocal as + friend. + * java/lang/natClass.cc (_Jv_GetMethodLocal): New function. + (_Jv_LookupInterfaceMethod): New function (rewrote from scratch). + + * include/jni.h: Added copyright header. + * include/javaprims.h: Added copyright header. + * include/java-field.h: Added copyright header. + * include/java-array.h: Added copyright header. + * include/cni.h: Added copyright header. + + * include/javaprims.h: Regenerated class declarations using + classes.pl; now they are complete. + * classes.pl: New file. + + * java/lang/natMath.cc: Include . + * java/lang/reflect/natField.cc: Include . + * java/util/NativeUtil.java: Removed. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added Math.h. + * java/lang/Math.h: Removed. + * java/util/natGregorianCalendar.cc: Added copyright header. + Include . + * java/lang/natFloat.cc: Added copyright header. + * java/lang/Byte.java: Added copyright header. + * java/lang/Void.java: Added copyright header. + * java/lang/Short.java: Added copyright header. + +Wed Oct 28 12:55:47 1998 Warren Levy + + * include/javaprims.h (java::io): Added bunch of missing classes. + + * java/io/DataInputStream.java (readLine): Added a special case + for handling BufferedInputStream data to reduce the likelihood + of a pushback error. + (skipBytes): Added code to handle negative number of skip bytes. + + * java/io/StreamTokenizer.java: Rewritten. + +1998-10-28 Tom Tromey + + * java/util/natGregorianCalendar.cc (computeFields): Call + getRawOffset as a method. + + * include/javaprims.h (java::io): Added FilterOutputStream. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added PrintStream.h, + FilterOutputStream.h. + * java/lang/natFirstThread.cc: Include System.h, Modifier.h, + PrintStream.h. + (die): New function. + (run): Die if `main' not found, is not public, or is not static. + + * boehm.cc (_Jv_MarkObj): Use new field names. + * include/java-field.h (JvGetFirstInstanceField): Use new field + names. + (JvNumInstanceFields): Likewise. + * java/lang/natClass.cc (isAssignableFrom): Use new field names. + (getInterfaces): Likewise. + * prims.cc (CLASS_CONSTANTS): Removed. + (CLASS_CONST_SIZE): Likewise. + (CLASS_CONST_TAG): Likewise. + (CLASS_CONST_DATA): Likewise. + (CLASS_CONST_UTF8): Likewise. + (WORD2UTF): Likewise. + (CLASS_CLASS): Likewise. + (CLASS_PRIM_SIG): Likewise. + (CLASS_ARRAY_CACHE): Likewise. + (HASH_CHARS): Likewise. + (hashClassName): Likewise. + Many changes to use new field names. + * java/lang/Class.h (Class): Renamed fields to track compiler. + +1998-10-27 Tom Tromey + + * java/lang/natClass.cc: Use #pragma implementation. + (getComponentType): Moved into header. + (getModifiers): Likewise. + (getName): Likewise. + (getSuperclass): Likewise. + (isArray): Likewise. + (isPrimitive): Likewise. + * include/jvm.h (_Jv_FindClass): Declare. + * java/lang/natFirstThread.cc (run): Updated for new Class.h. + * java/lang/natSystem.cc (arraycopy): Updated for new Class.h. + * include/javaprims.h: Use _Jv_Method, not JvMethod. + * java/lang/Class.h: Rewrote from scratch. + * prims.cc: Many changes to work with new Class.h. + * include/java-field.h (CLASS_FIELDS): Removed. + (CLASS_SFIELDS): Likewise. + (CLASS_IFIELDS): Likewise. + (CLASS_NFIELDS): Likewise. + (CLASS_NIFIELDS): Likewise. + (CLASS_NSFIELDS): Likewise. + (CLASS_FSIZE): Likewise. + (JvGetFirstInstanceField): Rewrote. + (JvNumInstanceFields): Likewise. + + * java/lang/Object.h: Added copyright comment. + +Wed Oct 28 00:32:23 1998 Per Bothner + + * java/text: New package directory. + * java/text/FieldPosition.java: New class. + * java/text/ParsePosition.java: New class. + * java/text/ParseException.java: New Exception class. + * java/text/Format.java: New class. + * java/text/NumberFormat.java: New (empty placeholder) class. + * java/text/DateFormatSymbols.java: New class (no Locales support). + * java/text/DateFormat.java: New Format class (incomplete). + * java/text/SimpleDateFormat.java: New DateFormat class. + + * include/javaprims.h (java::test): Added new package and classes. + * java/util/Calendar.java (clone): New method. + * java/util/Date.java (toString): Added non-native implementation. + (parse): Made public instead of synchronized. + * java/util/natDate.cc (toString): Removed. + * java/util/natGregorianCalendar.cc (computeFields): + Use gmtime (or gmtime_r) if no zone offset (the default, for now!). + +1998-10-27 Tom Tromey + + * boehm.cc (_Jv_MarkObj): Correctly mark a class' interfaces. + + * prims.cc (lookupArray): Added explanatory comment. + * boehm.cc (_Jv_MarkObj): Correctly scan methods and fields of + class. Mark the class of each object. + (_Jv_MarkArray): Mark the object's class. + + * configure: Rebuilt. + * configure.in: Create java-gc.h. + * include/boehm-gc.h: New file. + * include/no-gc.h: New file. + * java/lang/Class.h (Class): Declare JV_MARKOBJ_DECL as friend, if + defined. + * java/lang/Object.h: Include java-gc.h. + (Object): Declare JV_MARKOBJ_DECL and JV_MARKARRAY_DECL as + friends, if defined. + * boehm.cc (_Jv_MarkObj): Renamed from mark_obj; changed + signature. + (_Jv_MarkArray): Renamed from mark_array; changed signature. + +1998-10-26 Tom Tromey + + * java/lang/natCharacter.cc (isSpaceChar): Look for line and + paragraph separators, not numbers. + + * java/io/Writer.java (write): Removed write(char) to avoid + ambiguity. + * java/util/Properties.java: Rewrote from scratch. + * include/javaprims.h (java::io): Added PrintWriter, + BufferedWriter, PushbackReader. + +Mon Oct 26 13:13:28 1998 Anthony Green + + * java/lang/System.java: exit() is a static method. + +1998-10-26 Tom Tromey + + * java/lang/natString.cc (_Jv_NewStringUTF): Use + _Jv_strLengthUtf8. + (_Jv_NewStringUtf8Const): Likewise. + * include/jvm.h (_Jv_strLengthUtf8): Declare. + * prims.cc (_Jv_strLengthUtf8): Renamed from strLengthUtf8. + + * java/lang/Object.h (Object): Add mark_array as friend function. + * prims.cc (_Jv_NewPrimArray): Use _Jv_AllocObj, not + _Jv_AllocBytes, to ensure that header is marked. + * boehm.cc (mark_obj): Push sync_info field for all objects, not + just Objects. + (mark_array): Push sync_info field for array. + +1998-10-24 Tom Tromey + + * java/lang/String.java (String): Updated for StringBuffer + change. + * java/util/BitSet.java: Renamed field (data->bits) to conform to + serialization spec. + * java/lang/StringBuffer.java: Renamed fields to conform to + serialization spec: buffer->value, next->count, copy->shared. + +Wed Oct 21 18:24:57 1998 Per Bothner + + * java/util/TimeZone.java: New class. + * java/util/SimpleTimeZone.java: New class. + * java/util/Locale.java: New file. + * java/util/Calendar.java: Make almost complete. + * java/util/GregorianCalendar.java + * java/util/natGregorianCalendar.cc: New file. + * java/util/Date.java: Re-written from scratch. + * java/util/natDate.cc (setTime): Removed - no longer native. + * include/javaprims.h (java::util): Add new classes. + * Makefile.am (nat_files): Add java/util/natGregorianCalendar.o. + (nat_headers); Add TimeZone.h, Calendar.h, GregorianCalendar.h. + +Sat Oct 24 22:58:25 1998 Warren Levy + + * java/io/natFileDescriptorPosix.cc (read): Zero extend jbyte b before + returning it as a jint. + +1998-10-23 Tom Tromey + + * prims.cc (arg_vec, main_group, main_thread): New globals. + (JvRunMain): Use them. + +Fri Oct 23 17:10:12 1998 Warren Levy + + * java/io/DataInputStream.java: Rewritten. + + * java/io/DataOutputStream.java (writeUTF): OR secondary and + tertiary bytes with 0x80 per spec. + +1998-10-23 Tom Tromey + + * java/lang/String.java (init): Changed name of `copy' argument. + * java/lang/natString.cc (init): Inverted sense of `copy' + argument. + + * java/lang/Object.h (Object): Declare mark_obj as a friend. + * java/lang/Class.h (Class): Declare mark_obj as a friend. + * boehm.cc (ObjectClass): New define. + (ClassClass): Likewise. + (mark_obj): Special-case Object and Class. + + * prims.cc (_Jv_NewPrimArray): Pass correct args to memset. + + * java/util/BitSet.java: Rewrote from scratch. + + * prims.cc (lookupArray): Removed useless cast. + + * java/lang/natObject.cc: Use `#pragma implementation'. + + * java/lang/String.java (init): Added `copy' argument. + (String): Look in StringBuffer to find char array. + * java/lang/natString.cc (init): Added `copy' argument. + * java/lang/StringBuffer.java: Rewrote from scratch. + + * java/lang/Compiler.java: Rewrote from scratch. + * java/lang/Throwable.java: Don't use NativeLang. + * include/javaprims.h (java::lang): Don't mention NativeLang. + * java/lang/Process.java: Rewrote from scratch. + * java/lang/SecurityManager.java (classLoaderDepth): Commented + out. + (currentClassLoader): Likewise. + (currentLoadedClass): Likewise. + * java/lang/natClass.cc (getClassLoader): Commented out. + * java/lang/Class.java (getClassLoader): Commented out. + * java/lang/Compiler.java: Removed. + * java/lang/NativeLang.java: Removed. + + * java/lang/natFirstThread.cc (run): Use _Jv_makeUtf8Const. + * include/jvm.h (StringClass): Declare _Jv_makeUtf8Const. + * prims.cc (_Jv_makeUtf8Const): Renamed from makeUtf8Const. + (_Jv_hashUtf8String): Now static. + * include/java-field.h (getNameUtf8Const): Use `_Jv_Utf8Const' as + name of return type. + + * java/lang/Class.h (Class): Declare checkMemberAccess. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added Member.h. + * java/lang/natClass.cc: Include Member.h. + (getDeclaredClasses): Call checkMemberAccess. + * java/lang/Class.java (checkMemberAccess): Call + SecurityManager.checkMemberAccess. + +Fri Oct 23 08:01:54 1998 Anthony Green + + * java/lang/SecurityManager.java: Rewritten. + +Thu Oct 22 17:16:10 1998 Anthony Green + + * java/applet/Applet.java, java/applet/AppletContext.java, + java/applet/AppletStub.java, java/applet/AudioClip.java, + java/awt/AWTError.java, java/awt/AWTException.java, + java/awt/BorderLayout.java, java/awt/Button.java, + java/awt/Canvas.java, java/awt/CardLayout.java, + java/awt/Checkbox.java, java/awt/CheckboxGroup.java, + java/awt/CheckboxMenuItem.java, java/awt/Choice.java, + java/awt/Color.java, java/awt/Component.java, + java/awt/Container.java, java/awt/Dialog.java, + java/awt/Dimension.java, java/awt/Event.java, + java/awt/FileDialog.java, java/awt/FlowLayout.java, + java/awt/Font.java, java/awt/FontMetrics.java, + java/awt/Frame.java, java/awt/Graphics.java, + java/awt/GridBagConstraints.java, java/awt/GridBagLayout.java, + java/awt/GridLayout.java, java/awt/Image.java, + java/awt/Insets.java, java/awt/Label.java, + java/awt/LayoutManager.java, java/awt/List.java, + java/awt/MediaTracker.java, java/awt/Menu.java, + java/awt/MenuBar.java, java/awt/MenuComponent.java, + java/awt/MenuContainer.java, java/awt/MenuItem.java, + java/awt/Panel.java, java/awt/Point.java, java/awt/Polygon.java, + java/awt/Rectangle.java, java/awt/Scrollbar.java, + java/awt/TextArea.java, java/awt/TextComponent.java, + java/awt/TextField.java, java/awt/Toolkit.java, + java/awt/Window.java, java/awt/image/ColorModel.java, + java/awt/image/CropImageFilter.java, + java/awt/image/DirectColorModel.java, + java/awt/image/FilteredImageSource.java, + java/awt/image/ImageConsumer.java, + java/awt/image/ImageFilter.java, + java/awt/image/ImageObserver.java, + java/awt/image/ImageProducer.java, + java/awt/image/IndexColorModel.java, + java/awt/image/MemoryImageSource.java, + java/awt/image/PixelGrabber.java, + java/awt/image/RGBImageFilter.java, java/awt/peer/ButtonPeer.java, + java/awt/peer/CanvasPeer.java, + java/awt/peer/CheckboxMenuItemPeer.java, + java/awt/peer/CheckboxPeer.java, java/awt/peer/ChoicePeer.java, + java/awt/peer/ComponentPeer.java, + java/awt/peer/ContainerPeer.java, java/awt/peer/DialogPeer.java, + java/awt/peer/FileDialogPeer.java, java/awt/peer/FramePeer.java, + java/awt/peer/LabelPeer.java, java/awt/peer/ListPeer.java, + java/awt/peer/MenuBarPeer.java, + java/awt/peer/MenuComponentPeer.java, + java/awt/peer/MenuItemPeer.java, java/awt/peer/MenuPeer.java, + java/awt/peer/PanelPeer.java, java/awt/peer/ScrollbarPeer.java, + java/awt/peer/TextAreaPeer.java, + java/awt/peer/TextComponentPeer.java, + java/awt/peer/TextFieldPeer.java, java/awt/peer/WindowPeer.java, + java/net/ContentHandler.java, java/net/ContentHandlerFactory.java, + java/net/DatagramPacket.java, java/net/DatagramSocket.java, + java/net/DefaultSocketImpl.java, java/net/InetAddress.java, + java/net/MalformedURLException.java, java/net/NativeNet.java, + java/net/ProtocolException.java, java/net/ServerSocket.java, + java/net/Socket.java, java/net/SocketException.java, + java/net/SocketImpl.java, java/net/SocketImplFactory.java, + java/net/URL.java, java/net/URLConnection.java, + java/net/URLEncoder.java, java/net/URLStreamHandler.java, + java/net/URLStreamHandlerFactory.java, + java/net/UnknownHostException.java, + java/net/UnknownServiceException.java: Removed. + +1998-10-22 Tom Tromey + + * prims.cc (_Jv_AllocObject): Register finalizer if class' + finalizer is not Object.finalize. + (internalAddClass): Don't set `final' member of class. + * java/lang/Object.h: Updated _JvObjectPrefix comment to mention + other places that know about finalize() location. + * java/lang/Class.h (Class): Removed `final' field. + + * aclocal.m4, configure: Rebuilt. + * acinclude.m4 (LIB_AC_PROG_CXX): Unconditionally use + AC_CHECK_PROGS; otherwise the CXX cache variable might not be + set. + * configure.in (AC_OUTPUT): Pass CXX to config.status. + * Makefile.in: Rebuilt. + * Makefile.am (AM_MAKEFLAGS): Added CXX, CXXFLAGS. + +1998-10-21 Tom Tromey + + * java/lang/Object.java (finalize): Move to be first method in + class. + + * configure: Rebuilt. + * configure.in (GCINCS): Include contents of boehm-cflags file. + +Tue Oct 20 13:11:04 1998 Alexandre Petit-Bianco + + * java/lang/ArrayIndexOutOfBoundsException.java + (ArrayIndexOutOfBoundsException): Fixed string literal. + * java/lang/StringIndexOutOfBoundsException.java + (StringIndexOutOfBoundsException): Fixed string literal. + +1998-10-20 Andrew Haley + + * natFileDescriptorEcos.cc added. + * natFileDescriptor.cc renamed natFileDescriptorPosix.cc. + +1998-10-20 Andrew Haley + + * acconfig.h: test for __int32_t and __uint32_t added. + * include/config.h.in: test for __int32_t and __uint32_t added. + * java/lang/fdlibm.h: test for __int32_t and __uint32_t added. + * java/lang/mprec.h: test for __int32_t and __uint32_t added. + * configure.in: test for __int32_t and __uint32_t added. + * configure: test for __int32_t and __uint32_t added. + + * natFileDescriptor.cc renamed natFileDescriptorPosix.cc. + + * configure.in: Test for --enable ecos and link + natFileDescriptor.cc to natFileDescriptorEcos.cc or + natFileDescriptorPosix.cc + + * java/lang/dtoa.c: #include moved inside #ifdef DEBUG. + +Mon Oct 19 18:13:58 1998 Warren Levy + + * java/io/ByteArrayInputStream.java (skip): Ensure that arg passed + in isn't negative. + + * java/io/CharArrayReader.java (close): Synchronize on lock + object per Reader contract. + (read): Synchronize on lock obj. Verify that reader wasn't closed. + (reset): Synchronize on lock obj. Verify that reader wasn't closed. + (skip): Synchronize on lock obj. Verify that reader wasn't closed. + Ensure that arg passed in isn't negative. + + * java/io/FilterReader.java (FilterReader): Use the lock obj when + constructing the superclass. + + * java/io/PushbackReader.java (close): Synchronize on lock + object per Reader contract. + (read): Synchronize on lock obj. Verify that reader wasn't closed. + (ready): Synchronize on lock obj. Throw IOException if reader + wasn't closed. + (reset): Synchronize on lock obj. Verify that reader wasn't closed. + (skip): Synchronize on lock obj. Verify that reader wasn't closed. + Ensure that arg passed in isn't negative. + (unread): Synchronize on lock obj. Verify that reader wasn't closed. + + * java/io/StringReader.java: Created. + +Sun Oct 18 02:19:11 1998 Warren Levy + + * java/io/CharArrayReader.java (mark): Removed synchronized modifier + to match JCL. + (read): Removed synchronized modifier to match JCL. + (reset): Removed synchronized modifier to match JCL. + (skip): Removed synchronized modifier to match JCL. + +Sun Oct 18 02:01:54 1998 Warren Levy + + * java/io/PushbackReader.java (PushbackReader): Made + constructors public. + +1998-10-17 Tom Tromey + + * java/io/PushbackInputStream.java (PushbackInputStream): Made + constructors public. + +1998-10-16 Anthony Green + + * aclocal.m4, configure: Rebuilt. + * acinclude.m4 (LIBJAVA_CONFIGURE): Changed for new + configure.host. + * configure.host: Rewrote. + * Makefile.in: Rebuilt. + * Makefile.am (AM_CXXFLAGS): Added LIBJAVA_CXXFLAGS. + (AM_CFLAGS): New macro. + ($(c_files)): Use COMPILE macro. + (EXTRA_libjava_a_SOURCES): Added dummy file to work around + automake problem(s). + +Fri Oct 16 16:36:28 1998 Warren Levy + + * java/io/ByteArrayInputStream.java (mark): Removed temp. comment. + + * java/io/CharArrayReader.java: Created. + +Fri Oct 16 15:17:01 1998 Warren Levy + + * java/io/PushbackInputStream.java (PushbackInputStream): Changed + size check to allow 0 per JCL. + + * java/io/PushbackReader.java: Created. + +1998-10-16 Tom Tromey + + * java/io/natFileDescriptor.cc: Conditionalize , + includes. + * java/io/natFile.cc: Conditionalize include. + * include/no-threads.h: Conditionalize include on + HAVE_UNISTD_H. + +Fri Oct 16 14:39:51 1998 Andrew Haley + + * include/no-threads.h: Don't include unless HAVE_SLEEP + is defined. + +Thu Oct 15 19:27:54 1998 Warren Levy + + * java/io/FilterReader.java: Created. + +Thu Oct 15 17:49:43 1998 Warren Levy + + * java/io/PushbackInputStream.java: Rewritten. + + * java/io/BufferedInputStream.java (BufferedInputStream): Check + that size passed to constructor is legal. + (read): Check that args passed in are legal. + (skip): Rewritten to get rid of the temporary buffer. + (refill): Added marklimit check to grow the buffer. + + * java/io/ByteArrayInputStream.java (read): Optimized invalid args + check. + (bytesAvail): Removed. + (read): Changed bytesAvail to Math.min. + (skip): Changed bytesAvail to Math.min. + + * java/io/InputStream.java (read): Got rid of extraneous exceptions + from the throws clause. + (skip): Rewritten to use a temporary buffer. + +Thu Oct 15 19:42:55 1998 Andrew Haley + + * prims.cc: (JvConvertArgv): Check added for argc < 0; possible on + some target OSes + + * java/lang/dtoa.c: (print): Made #ifdef DEBUG only. + + * java/lang/strtod.c: (_strtod_r): Don't use HUGE_VAL: it's faster + to write the double one word at a time. + +Tue Oct 13 14:41:47 1998 Warren Levy + + * java/io/BufferedInputStream.java: Rewritten. + +1998-10-12 Tom Tromey + + * jni.cc: Include config.h and stddef.h. + + * java/lang/Class.h (_dispatchTable): Removed again. + Removed all ACC_* defines again. + +Fri Oct 9 17:08:34 1998 Per Bothner + + * Makefile.am (nat_files): Add netField.o. + (libjava_a_SOURCES): Add jni.cc. + (java/lang/reflect/Field.h): New rule. + * Makefile.in: Re-generated. + * include/javaprims.h: Add some extra class and typedefs. + * include/jni.h: New file. + * jni.cc: New file. + + * include/java-field.h: New file. + * include/jvm.h: #include . + * boehm.cc: #include . + * java/lang/Class.h (JvField, inline numbers): Moved to java-field.h. + * java/lang/reflect/Member.java: New class. + * java/lang/reflect/Field.java: New class. (Very incomplete.) + * java/lang/reflect/natField.cc: New file. (Very incomplete.) + +Sun Oct 11 00:34:44 1998 Anthony Green + + * Makefile.in, aclocal.m4, configure, test/Makefile.in, + testsuite/Makefile.in: Rebuilt. + * Makefile.am, acinclude.m4, configure.in: Add multilib support. + * configure.host: Created. + +1998-10-10 Tom Tromey + + * java/lang/natObject.cc (sync_init): Always allocate a new + sync_info. + +1998-10-09 Tom Tromey + + * java/io/ByteArrayInputStream.java (mark): Renamed from + `mark_FIXME'. + + * java/io/FileOutputStream.java (finalize): Removed. + * java/io/FileDescriptor.java (finalize): New method. + +Thu Oct 8 17:59:43 1998 Warren Levy + + * ByteArrayInputStream.java: Corrected status comment. + +Thu Oct 8 17:22:49 1998 Warren Levy + + * ByteArrayInputStream.java, FilterInputStream.java: Rewritten. + +1998-10-08 Tom Tromey + + * prims.cc (lookupArray): Use static array to initialize list of + interfaces. + +Thu Oct 8 12:45:03 1998 Anthony Green + + * prims.cc (lookupArray): Initialize the msize for new + array classes. + +Wed Oct 7 12:13:59 1998 Anthony Green + + * configure: Rebuilt. + * configure.in: Check for fsync and sleep. + * acconfig.h (HAVE_SLEEP, HAVE_FSYNC): Added. + + * include/no-threads.h (_Jv_CondWait): Wrap sleep() use with + HAVE_SLEEP. Include config.h. + + * java/io/natFileDescriptor.cc (NO_FSYNC_MESSAGE): Added. + * java/io/natFileDescriptor.cc (sync): Wrap fsync() use + with HAVE_FSYNC. + +1998-10-08 Tom Tromey + + * java/io/natFile.cc: Don't include SecurityManager.h. + (performList): Renamed. + (performMkdir): Likewise. + (performRenameTo): Likewise. + (performDelete): Likewise. + Include . + * java/io/File.java (performDelete): Renamed from natDelete. + (list): Now written in Java. + (performList): New method. + (performMkdir): New method. + (mkdir): Now written in Java. + (performRenameTo): New method. + (renameTo): Now written in Java. + +1998-10-06 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (ETAGS_ARGS): New macro. + (TAGS_DEPENDENCIES): Likewise. + +Tue Oct 6 22:04:44 PDT 1998 Anthony Green + + * Makefile.in: Rebuilt. + * Makefile.am: Use -classpath option with javac. + +Tue Oct 6 18:51:31 1998 Tom Tromey + + * java/io/FileOutputStream.java (finalize): Call + super.finalize(). + +Tue Oct 6 16:02:45 1998 Anthony Green + + * java/lang/mprec.h: Remove unused _mprec_log10 which conflicts + with newlib's libm. + * java/lang/mprec.c: Ditto. + + * java/lang/mprec.h: Include math.h for HUGE_VAL when + cross-compiling. + +Tue Oct 6 14:27:00 1998 Warren Levy + + * java/io/InputStream.java (skip): Make local var i a long. + +Mon Oct 5 09:44:24 1998 Tom Tromey + + * java/lang/natObject.cc (clone): Use memcpy, not memmove. + * prims.cc (lookupArray): Use memcpy, not memmove. + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_MEMCPY): Added. + * configure: Rebuilt. + * configure.in: Check for memcpy again. + + * java/io/RandomAccessFile.java (RandomAccessFile): Use + String.compareTo, not ==. + + * java/lang/Class.h (Class): Use _Jv_DispatchTable. + (_PRIMITIVE_DTABLE): Use _Jv_DispatchTable. + * java/lang/natObject.cc (struct _dispatchTable): Removed. + * include/jvm.h (struct _Jv_DispatchTable): New structure. + * prims.cc (lookupArray): Removed dead code. Copy Object's dtable + into new array's dtable. + (_Jv_AllocObject): Use _Jv_DispatchTable. + (_Jv_NewPrimArray): Likewise. + (_Jv_NewObjectArray): Likewise. + +Fri Oct 2 18:57:14 1998 Alexandre Petit-Bianco + + * prims.cc (_Jv_ThrowBadArrayIndex): Construct a string with the + offending index value. + (_Jv_NewPrimArray): Throw NegativeArraySizeException when + appropriate. + * include/jvm.h (_Jv_ThrowBadArrayIndex): Added declaration. + * java/lang/Throwable.java: (Throwable): fixed argument to this(). + +Fri Oct 2 15:58:23 1998 Warren Levy + + * java/io/DataInput.java, java/io/InputStream.java: Rewritten. + + * java/io/OutputStream.java (write): Use off and len parameters to + output partial byte array. + + * java/io/BufferedReader.java, java/io/FileReader.java, + java/io/InputStreamReader.java, java/io/LineNumberReader.java, + java/io/OutputStreamWriter.java, java/io/PrintWriter.java, + java/io/Reader.java, java/io/UnsupportedEncodingException.java, + java/io/Writer.java: Added COPYRIGHT-TBD comment. + + * include/javaprims.h (java::lang): Added + ExceptionInInitializerError, IllegalStateException, + NoSuchFieldException, and UnsupportedOperationException. + +Fri Oct 2 01:05:38 1998 Tom Tromey + + * java/lang/natObject.cc (CloneableClass): Is a Class, not a + Class*. + + * include/java-array.h (__JArray): Added clone method. + * prims.cc (CloneableClass): New define. + (lookupArray): Initialize array class to indicate that it + implements Cloneable. + + * java/lang/Class.h: Removed all ACC_* defines. + * prims.cc: Include Modifier.h. + (_Jv_LookupInterfaceMethod): Use methods in + java.lang.reflect.Modifier, not ACC_ defines. + + * java/lang/Class.h (Class): Declare getClasses, + getDeclaredClasses, getDeclaringClass, getModifiers, + * java/lang/Class.java: Rewrote from scratch. + + * include/javaprims.h (java::lang): Added reflect and + reflect::Modifier. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added Modifier.h. + + * prims.cc (_Jv_IsInstanceOf): Return false if class is + primitive. + +Fri Oct 2 06:49:00 1998 Anthony Green + + * java/lang/natString.cc (_Jv_StringFindSlot): Use JvAssert + instead of test and abort. + + * java/lang/natString.cc (_Jv_NewStringUtf8Const): Add cast to + remove compiler warning. + +Fri Oct 2 12:33:44 1998 Andrew Haley + + * java/lang/natDouble.cc: zero terminate string. + * strtod.c: Set errno if no digits are found in fraction. + +Thu Oct 1 11:48:28 1998 Tom Tromey + + * java/lang/reflect/Modifier.java: New file. + + * java/lang/VirtualMachineError.java: Rewrote from scratch. + * java/lang/VerifyError.java: Rewrote from scratch. + * java/lang/UnsatisfiedLinkError.java: Rewrote from scratch. + * java/lang/UnknownError.java: Rewrote from scratch. + * java/lang/StackOverflowError.java: Rewrote from scratch. + * java/lang/OutOfMemoryError.java: Rewrote from scratch. + * java/lang/InternalError.java: Rewrote from scratch. + * java/lang/IllegalAccessError.java: Rewrote from scratch. + * java/lang/ExceptionInInitializerError.java: New file. + * java/lang/Error.java: Rewrote from scratch. + * java/lang/ClassFormatError.java: Rewrote from scratch. + * java/lang/ClassCircularityError.java: Rewrote from scratch. + * java/lang/AbstractMethodError.java: Rewrote from scratch. + * java/lang/NoClassDefFoundError.java: Rewrote from scratch. + * java/lang/NoSuchFieldError.java: Rewrote from scratch. + * java/lang/LinkageError.java: Rewrote from scratch. + * java/lang/IncompatibleClassChangeError.java: Rewrote from + scratch. + * java/lang/NoSuchMethodError.java: Rewrote from scratch. + + * java/lang/natObject.cc (_Jv_FinalizeObject): New function. + * java/lang/Object.h (Object): Declare _Jv_FinalizeObject as a + friend. + * include/cni.h (JvAllocObject): Moved from prims.cc. + Include Class.h. + * prims.cc (JvAllocObject): Moved to cni.h. + (_Jv_AllocObject): Use _Jv_FinalizeObject. + (finalize_name): Removed. + +Wed Sep 30 12:09:34 1998 Tom Tromey + + * java/lang/Class.h (Class): Added size() method. + * prims.cc (_Jv_MonitorEnter): Removed. + (_Jv_MonitorExit): Removed. + * java/lang/Object.h (JvSyncInfo): Removed. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added Cloneable.h, + CloneNotSupportedException.h. + * java/lang/Object.h: Rewrote. + * java/lang/natObject.cc: Rewrote from scratch. + * java/lang/Object.java: Rewrote from scratch. + + * java/io/natFile.cc: Conditionally include . + (list): If no , always return NULL. + * configure: Rebuilt. + * configure.in: Check for dirent.h. + + * prims.cc (lookupArray): Don't use sprintf. + + * java/util/Hashtable.java (containsKey): Use `abs' to compute + initial index. + (get): Likewise. + (put): Likewise. + (rehash): Likewise. + (remove): Likewise. + + * java/util/Hashtable.java (hsize): Renamed from size to avoid + name conflict with method. + + * include/javaprims.h (java::util): Added HashtableEntry. + +Tue Sep 29 16:48:01 1998 Warren Levy + + * java/util/Hashtable.java: Rewritten. + +Tue Sep 29 00:28:42 1998 Tom Tromey + + * java/io/natFileDescriptor.cc (write): Correctly test `write' + return value. + (write): Likewise. + + * java/lang/natThread.cc (join): Fixed assertion to refer to `nt', + not `curr_nt'. + + * posix-threads.cc (_Jv_CondWait): Now returns int. + * include/javaprims.h (java::lang): Added + IllegalMonitorStateException. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added IllegalMonitorStateException.h. + * include/no-threads.h (_Jv_CondDestroy): Removed. + (_Jv_MutexDestroy): Removed. + (_Jv_CondWait): Now returns int. + (_Jv_CondNotify): Likewise. Added mutex argument. + (_Jv_CondNotifyAll): Likewise. + (_Jv_MutexLock): Always succeed. + (_Jv_MutexUnlock): Likewise. + * include/posix-threads.h (_Jv_HaveCondDestroy): Define. + (_Jv_HaveMutexDestroy): Define. + (_Jv_CondNotify): Now returns int. Added mutex argument. + (_Jv_CondNotifyAll): Likewise. + * include/quick-threads.h (_Jv_CondDestroy): Removed. + (_Jv_MutexDestroy): Removed. + (_Jv_CondWait): Now returns int. + (_Jv_CondNotify): Likewise. Added mutex argument. + (_Jv_CondNotifyAll): Likewise. + * java/lang/natObject.cc (finalize_sync_info): New function. + (init_mutex): Initialize `init' and register finalizer if + required. + (CHECK): New macro. + (init_mutex): Use it. + (notify): Use it. + (notifyAll): Use it. + (wait): Use it. + (notify): Throw IllegalMonitorStateException on failure. + (notifyAll): Likewise. + (wait): Likewise. Also, throw InterruptedException if + appropriate. + Include cni.h, Thread.h, IllegalMonitorStateException.h, + InterruptedException.h, IllegalArgumentException.h. + * java/lang/Object.h (struct JvSyncInfo): Added `init' member. + + * java/lang/natString.cc: Renamed all `JvPriv' functions. + * java/lang/natRuntime.cc: Renamed all `JvPriv' functions. + * java/lang/Object.h: Renamed all `JvPriv' functions (and types). + * java/lang/natObject.cc: Renamed all `JvPriv' functions. + * java/lang/natThread.cc: Renamed all `JvPriv' functions. + * quick-threads.cc: Renamed all `JvPriv' functions. + * prims.cc: Renamed all `JvPriv' functions. + * posix-threads.cc: Renamed all `JvPriv' functions. + * nogc.cc: Renamed all `JvPriv' functions. + * no-threads.cc: Renamed all `JvPriv' functions. + * boehm.cc: Renamed all `JvPriv' functions. + * include/quick-threads.h: Renamed all `JvPriv' functions. + * include/posix-threads.h: Renamed all `JvPriv' functions. + * include/no-threads.h: Renamed all `JvPriv' functions. + * include/jvm.h: Renamed all `JvPrivXXX' functions to `_Jv_XXX'. + + * include/no-threads.h (JvPrivCondWait): Wrote minimal + implementation. + (JvPrivCondNotify): Do nothing. + (JvPrivCondNotifyAll): Do nothing. + + * prims.cc (processClass): Handle case where state is + DOING_CONSTINIT. + + * java/lang/natFirstThread.cc: Include + + * configure: Rebuilt. + * configure.in: Fixed sense of --enable-libjava-debug. + + * java/lang/natThread.cc (join): Declare `t' outside the loop so + it can be used afterward by the assertion. + + * configure: Rebuilt. + * configure.in: When cross-compiling, assume alloca. + + * java/lang/natDouble.cc: Updated alloca magic to avoid use of + __builtin_alloca (autoconf docs are wrong here). + + * java/io/natFileDescriptor.cc (close): Set fd to -1 before + closing. + (available): Use `FD_ZERO' (typo fix). + +Tue Sep 29 17:43:30 1998 Andrew Haley + + * java/lang/mprec.h, java/lang/mprec.c, java/lang/dtoa.c, + java/lang/natDouble.cc, java/lang/strtod.c: struct _Bigint renamed + struct _Jv_Bigint. + * java/lang/mprec.h, java/lang/mprec.c, java/lang/dtoa.c, + java/lang/natDouble.cc, java/lang/strtod.c: struct _reent renamed + struct _Jv_reent. + + * java/lang/natDouble.cc: layout changed to match GNU coding standard. + +Tue Sep 29 07:57:13 1998 Anthony Green + + * java/lang/natDouble.cc: Declare alloca safely. + + * configure, include/config.h.in: Rebuilt. + * configure.in: Add alloca check. + +Tue Sep 29 00:28:42 1998 Tom Tromey + + * java/lang/natThread.cc (finish_): Hold mutex for interrupt + condition while calling notify. + (join): Remove `curr_nt' from `nt's join list, not vice versa. + (interrupt): Hold mutex for interrupt condition while calling + notify. + + * java/lang/natString.cc (init): Allocate and try to read `count' + characters, not `count - offset' characters. + + * java/io/ByteArrayInputStream.java (ByteArrayInputStream): + Correctly compute `count'. + + * java/lang/Boolean.java (getBoolean): Return false if property + not found. + + * java/lang/System.java (setProperties): Set prop_init. + +Mon Sep 28 12:39:25 1998 Tom Tromey + + * java/io/PrintStream.java (println): Use line.separator, not + file.separator. + * java/lang/System.java (out, err): Make both autoflush streams. + * java/io/ByteArrayOutputStream.java (write): Increment `count'. + + * include/config.h.in: Rebuilt. + * acconfig.h (HAVE_MEMCPY): Removed. + * configure: Rebuilt. + * configure.in: Never define HAVE_MEMCPY. + + * java/lang/natString.cc: Don't include OutOfMemoryError.h or + Class.h. + (_Jv_AllocString): Use JvAllocObject again. + * java/lang/Class.h (thread): New field. + (_Jv_AllocString): No longer a friend. + * prims.cc (processClass): Removed dead code. Changed to more + closely follow the Java Language Specification. + (processClass): Return early if already at the right state. + + * prims.cc (JvNewStringUTF): Removed. + * include/cni.h (JvNewStringUTF): New function. + (_Jv_NewStringUTF): Declare as `extern "C"'. + * java/lang/natString.cc (_Jv_NewStringUTF): New function. + + * java/lang/natDouble.cc: Added copyright info and header + comment. Include . + (doubleValueOf): Use alloca, not malloc. Allocate 3 times as many + bytes as are chars in string. + +Sat Sep 26 00:19:27 1998 Tom Tromey + + * java/util/Hashtable.java (hkeys): Member renamed from to avoid + clash with method. + (hsize): Likewise. + + * java/lang/System.java (init_properties): Now native. + * java/lang/natSystem.cc (init_properties): New method. + Include java/util/Properties.h. + + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added ByteArrayOutputStream.h, + OutputStreamWriter.h, ByteArrayInputStream.h, + InputStreamReader.h, Writer.h, InputStream.h, OutputStream.h, + Reader.h, Vector.h, SecurityManager.h, FilenameFilter.h, + SyncFailedException.h, EOFException.h, FileNotFoundException.h, + Properties.h, Hashtable.h, Dictionary.h. + (CFLAGS): Removed. + + * include/javaprims.h (java::io): Added Reader, Writer, + InputStreamReader, OutputStreamWriter, + UnsupportedEncodingException, ByteArrayInputStream, + ByteArrayOutputStream, EOFException, SyncFailedException, + PushbackInputStream. + (java::lang): Added Cloneable. + (java::util): Added NoSuchElementException, VectorEnumeration, + Dictionary, HashtableEnumeration, PropertiesEnumeration. + + * java/io/PipedReader.java: New file. + +Fri Sep 25 00:11:25 1998 Tom Tromey + + * java/lang/natCharacter.cc (getNumericValue): Use `digit' to pick + up A-Z. + + * java/io/io-defs.h: Removed. + + * java/io/FileInputStream.java (skip): Use FileDescriptor.seek. + (FileInputStream): Use new constructor. Can throw IOException. + + * java/lang/System.java (getProperty): Don't throw + NullPointerException. + + * java/io/RandomAccessFile.java: Rewrote from scratch. + + * java/io/natFileDescriptor.cc: Include EOFException.h. + (seek): New method. + (length): New method. + (getFilePointer): New method. + (read): New method. + (available): New method. + * java/io/FileDescriptor.java (SET, CUR): New constants. + (seek, length, getFilePointer, read, available): New decls. + + * java/io/PipedWriter.java: New file. + * java/io/StringWriter.java: New file. + * java/io/CharArrayWriter.java: New file. + * java/io/CharConversionException.java: New file. + * java/io/BufferedWriter.java: New file. + * java/io/FilterWriter.java: New file. + * java/io/FileWriter.java: New file. + + * java/lang/natString.cc: Include ByteArrayOutputStream.h, + OutputStreamWriter.h, NullPointerException.h, + ByteArrayInputStream.h, InputStreamReader.h. + (getBytes): New method. + (init): Throw NullPointerException. + (init): New function. + * java/lang/String.java (getBytes): Added missing decl. + (getBytes): New method. + (String): Added byte[]-based constructors. + (copyValueOf): Wrote. + (init): Declare variant which takes byte array and encoding. + Import java.io.UnsupportedEncodingException. + + * java/io/File.java: Rewrote from scratch. + * java/io/natFileDescriptor.cc: Rewrote from scratch. + * java/io/FileDescriptor.java: Rewrote from scratch. + * java/io/FilenameFilter.java: Rewrote from scratch. + +Thu Sep 24 13:30:16 1998 Tom Tromey + + * java/io/SyncFailedException.java: New file. + * java/io/UTFDataFormatException.java: Rewrote from scratch. + * java/io/InterruptedIOException.java: Rewrote from scratch. + * java/io/FileNotFoundException.java: Rewrote from scratch. + * java/io/EOFException.java: Rewrote from scratch. + * java/io/IOException.java: Rewrote from scratch. + * java/io/PrintStream.java: Rewrote from scratch. + * java/io/DataOutputStream.java: Rewrote from scratch. + * java/io/BufferedOutputStream.java: Rewrote from scratch. + * java/io/FilterOutputStream.java: Rewrote from scratch. + * java/io/ByteArrayOutputStream.java: Rewrote from scratch. + * java/io/PipedOutputStream.java: Rewrote from scratch. + * java/io/FileOutputStream.java: Rewrote from scratch. + * java/io/OutputStream.java: Rewrote from scratch. + * java/io/DataOutput.java: Rewrote from scratch. + +Mon Sep 28 22:59:54 1998 Per Bothner + + * prims.cc (_Jv_CheckCast): Add missing ! operator. + +Mon Sep 28 15:50:06 1998 Anthony Green + + * configure.in: Add --enable-libjava-debug + + * Makefile.am (nat_headers): Add java/lang/Float.h and + java/lang/Double.h + + * acconfig.h: Add DEBUG and HAVE_MEMCPY. + + * Makefile.in, configure, include/config.h.in: Rebuilt. + +Mon Sep 28 17:05:58 1998 Andrew Haley + + * java/lang/Float.java: Rewritten + * java/lang/Double.java: Rewritten + * java/lang/natFloat.cc: toString() added. + * java/lang/natDouble.cc: toString() added. + * java/lang/natDouble.cc: doubleValueOf() added. + * java/lang/dtoa.c, java/lang/mprec.c, java/lang/mprec.h, + java/lang/strtod.c: added. + * ieeefp.h: __sparc added. + * Makefile.am: java/lang/Float.h and java/lang/Double.h added. + +Thu Sep 24 13:30:16 1998 Tom Tromey + + * include/javaprims.h (java::lang): Added + CloneNotSupportedException. + + * java/lang/Object.java (clone): No longer native. Implemented. + * java/lang/natObject.cc (clone): Removed. + +Wed Sep 23 12:03:38 1998 Tom Tromey + + * prims.cc: Don't make definitions `extern "C"'. + (_Jv_RegisterClass): Renamed from registerClass. + * include/jvm.h (_Jv_ThrowBadArrayIndex): Declare. + (_Jv_NewArray): Likewise. + (_Jv_NewMultiArray): Likewise. + (_Jv_CheckCast): Likewise. + (_Jv_LookupInterfaceMethod): Likewise. + (_Jv_CheckArrayStore): Likewise. + (_Jv_RegisterClass): Likewise. + + * acconfig.h (HAVE_FMOD, HAVE_MEMCPY): Removed. + * configure: Rebuilt. + * configure.in: Don't check for fmod; it is provided by the fdlibm + code. + * prims.cc (fmod): Removed. + + * java/lang/natString.cc (charAt): Use _Jv_uint. + * java/lang/Class.h (class JvField): Use _Jv_ushort. + * prims.cc (HASH_CHARS): Use _Jv_ushort. + (equalUtf8Consts): Likewise. + (internalAddClass): Use _Jv_uint. + (processClass): Likewise. + * include/javaprims.h (_Jv_ushort): Renamed from uint16. + (_Jv_uint): Renamed from uint32. + (struct _Jv_Utf8Const): Changed members to use new type names. + + * configure: Rebuilt. + * configure.in: Don't check for memcpy. Require memmove and a way + to get the time. + * java/lang/natSystem.cc (arraycopy): Removed dead code, and + #error. + (currentTimeMillis): Don't use #error. + +Tue Sep 22 18:00:16 1998 Andrew Haley + + * java/lang/Math.java: static member random renamed to random_ to + avoid conflict with member function of the same name. + * include/javaprims.h: java.util.Random added. + +Tue Sep 22 13:53:14 1998 Tom Tromey + + * include/java-chartables.h: Regenerated. + * chartables.pl: End COMPACT_CHARACTER #if after fast tables + printed. + +Tue Sep 22 17:17:52 1998 Andrew Haley + + * java/lang/Math.java: Rewritten. + * java/lang/natMath.cc: New file. + * Files added from fdlibm: + java/lang/e_acos.c, java/lang/k_sin.c, java/lang/sf_floor.c, + java/lang/e_asin.c, java/lang/k_tan.c, java/lang/sf_rint.c, + java/lang/e_atan2.c, java/lang/s_atan.c, java/lang/w_acos.c, + java/lang/e_exp.c, java/lang/s_ceil.c, java/lang/w_asin.c, + java/lang/e_fmod.c, java/lang/s_copysign.c, java/lang/w_atan2.c, + java/lang/e_log.c, java/lang/s_cos.c, java/lang/w_exp.c, + java/lang/e_pow.c, java/lang/s_fabs.c, java/lang/w_fmod.c, + java/lang/e_rem_pio2.c, java/lang/s_floor.c, java/lang/w_log.c, + java/lang/e_remainder.c, java/lang/s_rint.c, java/lang/w_pow.c, + java/lang/e_scalb.c, java/lang/s_scalbn.c, java/lang/w_remainder.c, + java/lang/e_sqrt.c, java/lang/s_sin.c, java/lang/w_sqrt.c, + java/lang/ef_fmod.c, java/lang/s_tan.c, java/lang/wf_fmod.c, + java/lang/k_cos.c, java/lang/sf_ceil.c, + java/lang/k_rem_pio2.c, java/lang/sf_fabs.c, + java/lang/ieeefp.h, java/lang/fdlibm.h + * Makefile.am: rules added for compiling C files from fdlibm. + +Mon Sep 21 15:40:58 1998 Tom Tromey + + * chartables.pl: Minor documentation fixes. + + * configure: Rebuilt. + * configure.in: Fixed --help output for --enable-fast-character. + +Thu Sep 17 11:03:27 1998 Tom Tromey + + * configure: Rebuilt. + * configure.in: Recognize --enable-fast-character. + * acconfig.h (COMPACT_CHARACTER): New define. + * include/config.h.in: Rebuilt. + * include/java-chartables.h: New file. + * Makefile.in: Rebuilt. + * Makefile.am (nat_files): Added natCharacter.o. + * java/lang/natCharacter.cc: New file. + * chartables.pl (set_attribute): New function. + (@attributes, @second_attributes): New globals. + ($ROMAN_START, $ROMAN_END): Likewise. + (process_char): Call set_attribute when required. + (print_char): Just print hex value. + (print_block): Generate C++ syntax. + (print_numerics): Likewise. + (print_single_map): Likewise. + (print_all_block): Likewise. + (print_case_table): Likewise. + (print_fast_tables): New function. + Generate C++ code suitable for a header file. + * java/lang/Character.java (table_search): Removed. + (digit_value): Now native. + (getNumericValue): Likewise. + (getType): Likewise. + Removed all automatically-generated tables. + (Tamil_Digit_One): Removed. + (isSpaceChar): Now native. + (isTitleCase): Likewise. + (isLowerCase): Likewise. + (isUpperCase): Likewise. + (toLowerCase): Likewise. + (toTitleCase): Likewise. + (toUpperCase): Likewise. + (isDefined): Fixed sense of test. + +Wed Sep 16 12:00:19 1998 Tom Tromey + + * java/lang/natString.cc (equalsIgnoreCase): Removed obsolete + FIXME comment. + (regionMatches): Likewise. + +Tue Sep 15 14:35:12 1998 Tom Tromey + + * prims.cc (_Jv_AllocObject): Call _Jv_InitClass on the class. + + * java/lang/Class.h (Object): For now, declare _Jv_AllocString as + a friend. + * java/lang/natString.cc (_Jv_AllocString): For now, don't call + _Jv_AllocObject. + + * java/lang/natString.cc (toUpperCase): Declare `ch' as a jchar, + not a char. + + * java/lang/natClass.cc (isAssignableFrom): Handle arrays. + +Fri Sep 11 14:01:08 1998 Tom Tromey + + * prims.cc (instanceof_class): Removed. + (instanceof_array): Likewise. + (instanceof): Likewise. + (_Jv_IsInstanceOf): Use Class::isAssignableFrom. + (_Jv_CheckCast): Likewise. + * java/lang/natClass.cc (isAssignableFrom): New method. + * java/lang/Class.java (isAssignableFrom): Now native. + + * include/cni.h (JvThrow): Use `extern inline'. + (JvAllocObject): Likewise. + (JvInitClass): Likewise. + + * java/lang/natSystem.cc (arraycopy): Only check class of source + object if not null. + + * prims.cc (_Jv_CheckArrayStore): Wrote. + (_Jv_MonitorEnter): Prefer `JvThrow'. + Include ArrayStoreException.h. + (_Jv_CheckCast): Indentation cleanup. + +Thu Sep 10 18:59:29 1998 Tom Tromey + + * chartables.pl: New file. + * java/lang/Character.java: Rewrote from scratch. + +Fri Sep 18 18:15:58 1998 Warren Levy + + * java/lang/ArithmeticException.java, + java/lang/ArrayIndexOutOfBoundsException.java, + java/lang/ArrayStoreException.java, + java/lang/ClassCastException.java, + java/lang/ClassNotFoundException.java, + java/lang/CloneNotSupportedException.java, + java/lang/Exception.java, java/lang/IllegalAccessException.java, + java/lang/IllegalArgumentException.java, + java/lang/IllegalMonitorStateException.java, + java/lang/IllegalThreadStateException.java, + java/lang/IndexOutOfBoundsException.java, + java/lang/InstantiationException.java, + java/lang/InterruptedException.java, + java/lang/NegativeArraySizeException.java, + java/lang/NoSuchMethodException.java, + java/lang/NullPointerException.java, + java/lang/NumberFormatException.java, + java/lang/RuntimeException.java, java/lang/SecurityException.java, + java/lang/StringIndexOutOfBoundsException.java: Rewritten. + + * java/lang/IllegalStateException.java, + java/lang/NoSuchFieldException.java, + java/lang/UnsupportedOperationException.java: Created. + +Fri Sep 18 15:01:42 1998 Warren Levy + + * java/lang/Integer.java, java/lang/Long.java: Rewritten. + * java/lang/Byte.java, java/lang/Short.java (decode): Uncommented. + +Fri Sep 11 16:49:19 1998 Per Bothner + + * prims.cc (JvRunMain): No longer need to call _Jv_InitClass. + +Thu Sep 10 12:23:55 1998 Warren Levy + + * Makefile.am (nat_headers): Added StringIndexOutOfBoundsException.h. + + * Makefile.in: Rebuilt. + + * include/javaprims.h (java::lang): Added + StringIndexOutOfBoundsException. + + * java/lang/String.java: Added header comment and FIXME comment for + missing constructors/methods. + (endsWith): Adjusted offset into string to look at just the last chars. + Commented out undocumented method. + + * java/lang/natString.cc: Added includes for + ArrayIndexOutOfBoundsException.h & StringIndexOutOfBoundsException.h. + (String::init): Throw StringIndexOutOfBoundsException. + (String::charAt): Throw StringIndexOutOfBoundsException. + (String::substring): Throw StringIndexOutOfBoundsException. + (String::getChars): Throw ArrayIndexOutOfBoundsException. + (String::getBytes): Throw ArrayIndexOutOfBoundsException. + (String::compareTo): Return difference/offset between chars/strings. + +Tue Sep 8 13:22:33 1998 Warren Levy + + * java/lang/Boolean.java (TYPE): Added comment. + + * java/lang/Byte.java (decode): Added - commented out until dependent + code for Integer is written. + (compareTo): JDK 1.2 methods written. + (hashCode): Added comment to note that values have been verified. + + * java/lang/Short.java (decode): Added - commented out until dependent + code for Integer is written. + (compareTo): JDK 1.2 methods written. + (hashCode): Added comment to note that values have been verified. + + * java/lang/Comparable.java: Created - JDK 1.2 interface. + +Fri Sep 4 10:36:35 1998 Tom Tromey + + * include/javaprims.h (java::lang): Added VirtualMachineError, + OutOfMemoryError. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added OutOfMemoryError.h, + VirtualMachineError.h. + * prims.cc (_Jv_NewPrimArray): Throw OutOfMemoryError. + (lookupArray): Likewise. + (makeUtf8Const): Likewise. + (_Jv_AllocObject): Likewise. + (_Jv_NewObjectArray): Likewise. + Include OutOfMemoryError.h. + + * java/io/natFileDescriptor.cc (newstr): Removed. Changed callers + to use JvNewStringLatin1. + + * java/io/io-defs.h: Include java/lang/IOException.h. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added + ArrayIndexOutOfBoundsException.h, + ClassFormatError.h,ClassNotFoundException.h, + ClassCircularityError.h, ClassCastException.h, + IncompatibleClassChangeError.h, AbstractMethodError.h, + IllegalAccessError.h, LinkageError.h, Error.h, + NegativeArraySizeException.h, IOException.h. + * include/cni.h (SignalError): Removed declaration. + * java/util/natDate.cc (setTime): Use JvFail, not sorry. + * java/lang/natObject.cc (clone): Use JvFail, not sorry. + * java/lang/natClass.cc (getInterfaces): Use JvFail, not sorry. + (newInstance): Likewise. + (forName): Likewise. + * java/io/natFileDescriptor.cc (open_read_write): Use JvFail, not + sorry. + (read): Use JvThrow, not SignalError. + (read): Likewise. + (write): Likewise. + (skip): Likewise. + (close): Likewise. + (open_read): Likewise. + (open_write): Likewise. + (ftell): Likewise. + (fseek): Likewise. + (newstr): New function. + * java/io/natFile.cc (isDirectoryUnchecked): Use JvFail, not + sorry. + (lastModifiedUnchecked): Likewise. + (lengthUnchecked): Likewise. + * include/javaprims.h (sorry): Removed declaration. + (java::lang): Added ArrayIndexOutOfBoundsException, LinkageError, + ClassFormatError, ClassNotFoundException, ClassCircularityError, + ClassCastException, IncompatibleClassChangeError, + AbstractMethodError, IllegalAccessError, NegativeArraySizeException. + * prims.cc (instanceof_array): Use JvFail, not sorry. + (sorry): Removed. + Include ArrayIndexOutOfBoundsException.h, + ClassFormatError.h,ClassNotFoundException.h, + ClassCircularityError.h, ClassCastException.h, + IncompatibleClassChangeError.h, AbstractMethodError.h, + IllegalAccessError.h, NegativeArraySizeException.h. + (_Jv_ThrowBadArrayIndex): Implemented. + (JvNewStringUTF): Use JvFail, not sorry. + (_Jv_FindClass): Likewise. + (_Jv_NewArray): Likewise. + (throwException): Removed. + (getClass): Use JvThrow. + (processClass): Likewise. + (_Jv_NewObjectArray): Likewise. + (_Jv_NewMultiArray): Likewise. + (_Jv_CheckCast): Likewise. + (_Jv_LookupInterfaceMethod): Likewise. + (SignalError): Removed. + (getClass): Use _Jv_NewStringUtf8Const to create String. + + * java/lang/natSystem.cc (arraycopy): Throw + ArrayIndexOutOfBoundsException, not IndexOutOfBoundsException. + + * Makefile.in: Rebuilt. + * Makefile.am (GCJH): Renamed. Now use `gcjh'. Changed all + users. + * include/java-array.h: Mention gcjh, not gjavah. + + * java/io/natFile.cc (existsUnchecked): Use JvGetStringUTFRegion. + (canReadUnchecked): Likewise. + (canWriteUnchecked): Likewise. + (isFileUnchecked): Likewise. + * java/io/natFileDescriptor.cc: Don't include cni.h. + + * java/lang/Thread.java (run__): Declare. + * java/lang/natThread.cc (run__): New method, to avoid compiler + warning. + (start): Use run__, not run_. + + * java/io/io-defs.h: Include cni.h and jvm.h. + +Thu Sep 3 18:20:08 1998 Per Bothner + + Re-implement java.lang.String, using "COMPACT_STRINGS" representation. + * prims.cc (JvAllocString, JvNewString, JvNewStringlatin1): Moved + to natString.cc (with suitable renaming, inlines etc). + (javaString2CString): Removed. Subsumed by _Jv_GetStringUTFRegion. + * java/lang/Class.h: Renamed Utf8Const to _Jv_Utf8Const. + * java/lang/String.h: Removed - now generated using gjavah. + * java/lang/String.java: Re-written from scratch. Many native methods. + * java/lang/natDouble.cc, java/util/natDate.cc: #include . + * java/lang/natString.cc: Many functions re-written for "compact + strings" representation, or native java.lang.String methods added. + (Utf8Const2JavaString): Renamed to _Jv_NewStringUtf8Const. + (_Jv_GetStringUTFLength, _Jv_GetStringUTFRegion): New methods. + * java/lang/natClass.cc (getName): Use new _Jv_NewStringUtf8Const. + * java/io/natFileDescriptor.cc: Use new JvGetStringUTFRegion. + * include/cni.h: Add inline method. + * include/java-array.h (jobjectArrayjchar): gjavah bug work-around. + * include/javaprims.h: Moved some stuff frm String.h. + * include/jvm.h (UTF8_GET, Utf8Const, StringClass): Moved here. + * Makefile.am (nat_header): Added Character.h and String.h. + (String.h): Add new rule. + +Thu Sep 3 10:28:16 1998 Tom Tromey + + * no-threads.cc: Include config.h, cni.h, jvm.h. Don't include + java-assert.h. + * posix-threads.cc: Include cni.h, jvm.h. + * quick-threads.cc: Include cni.h, jvm.h. + * nogc.cc: Include cni.h, not javaprims.h. + * java/lang/natFirstThread.cc: Include cni.h, jvm.h. + * java/lang/natThread.cc: Rearranged #include ordering. Don't + include java-assert.h. + * java/lang/natSystem.cc: Include cni.h. Don't include + java-assert.h. + * java/lang/natRuntime.cc: Include cni.h. Don't include + java-assert.h. + * prims.cc: Rearranged #include ordering. Don't include + java-array.h or java-assert.h. + * boehm.cc: Include config.h, cni.h. + * exception.cc: Include config.h, cni.h. + * include/jvm.h: Include java-assert.h. + * include/cni.h: Include java/lang/Object.h. Don't include + java-threads.h or java-array.h. + +Thu Sep 3 16:03:08 1998 Warren Levy + + * java/lang/Boolean.java: Rewritten. + +Thu Sep 3 10:28:16 1998 Tom Tromey + + * java/lang/natFirstThread.cc (main_func): New typedef. + (run): Use main_func, not JvPrivThreadStartFunc. + * include/no-threads.h (JvPrivThreadStartFunc): Use correct + argument type. + * include/posix-threads.h (JvPrivThreadStartFunc): Use correct + argument type. + * include/quick-threads.h (JvPrivThreadStartFunc): Use correct + argument type. + + Can't throw Java exceptions with C++ `throw': + * quick-threads.cc (qthrow): Use _Jv_Throw, not throw. + * java/lang/natThread.cc (join): Use _Jv_Throw, not throw. + (setPriority): Likewise. + (sleep): Likewise. + (start): Likewise. + (stop): Likewise. + * java/lang/natSystem.cc (arraycopy): Use _Jv_Throw, not throw. + * prims.cc (_Jv_MonitorEnter): Use _Jv_Throw, not throw. + + Can't catch Java exceptions from C++: + * java/lang/natThread.cc (finish_): New method. + (run_): Removed. + * java/lang/Thread.java (run_): Rewrote in Java. + (finish_): New native method. + +Wed Sep 2 17:30:39 1998 Warren Levy + + * java/lang/Cloneable.java, java/lang/Number.java: Rewritten. + + * include/javaprims.h (java::io): Added Serializable. + +Wed Sep 2 15:22:00 1998 Warren Levy + + * java/util/EmptyStackException.java, + java/util/NoSuchElementException.java: Rewritten. + + * java/util/ConcurrentModificationException.java, + java/util/MissingResourceException.java, + java/util/TooManyListenersException.java: Created. + +Wed Sep 2 13:36:57 1998 Tom Tromey + + * include/cni.h (JvThrow): New function. + * include/javaprims.h (_Jv_Throw): Declare. + +Wed Sep 2 14:07:48 1998 Warren Levy + + * java/util/Observable.java: Rewritten. + +Wed Sep 2 13:36:57 1998 Tom Tromey + + * prims.cc (_Jv_MonitorExit): Assert that object is non-null. + (_Jv_MonitorEnter): Throw NullPointerException if object is null. + Include NullPointerException.h. + +Tue Sep 1 12:07:35 1998 Tom Tromey + + * java/lang/natSystem.cc (arraycopy): Removed overlapping-copy + assignability checks. Don't bother using memcpy. + + * quick-threads.cc (JvPrivThreadStart): Don't call coop_start. + (started): Removed. + * include/quick-threads.h (JvPrivThreadWait): New function. + * include/no-threads.h (JvPrivThreadWait): New function. + * include/posix-threads.h (JvPrivThreadWait): New function. + * prims.cc (JvRunMain): Call JvPrivThreadWait. + + * java/lang/natSystem.cc (arraycopy): Do nothing if count is 0. + + * java/lang/natSystem.cc (arraycopy): Multiply both src and dst + offsets by size of type that is being copied. + + * java/lang/natThread.cc (start): Don't pass `object' argument to + JvPrivThreadStart. + * no-threads.cc (JvPrivThreadStart): Removed `object' argument. + * posix-threads.cc (JvPrivThreadStart): Removed `object' + argument. + * quick-threads.cc (JvPrivThreadStart): Removed `object' argument; + always pass thread as object. + * include/quick-threads.h, include/posix-threads.h, + include/no-threads.h (JvPrivThreadStart): Removed `object' + argument. + +Mon Aug 31 19:11:53 1998 Warren Levy + + * java/util/Dictionary.java: Rewritten. + +Mon Aug 31 14:35:55 1998 Tom Tromey + + * include/quick-threads.h (JvPrivThreadInitData): Use 0, not NULL. + (JvPrivThreadDestroy): Likewise. + +Mon Aug 31 12:56:01 1998 Warren Levy + + * java/lang/natRuntime.cc (exit): Changed final call to ::exit. + +Thu Aug 27 12:24:40 1998 Tom Tromey + + * java/lang/natSystem.cc: Rewrote from scratch. + * java/lang/System.java: Rewrote from scratch. + * java/lang/Class.h (Class): Declare isAssignableFrom. + * include/javaprims.h (java::lang): Added ArrayStoreException, + IndexOutOfBoundsException. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added ArrayStoreException.h, + IndexOutOfBoundsException.h. + * java/lang/natObject.cc (hashCode): Use _Jv_HashCode. + * include/jvm.h (_Jv_HashCode): New function. + + * java/lang/natThread.cc (suspend): Call checkAccess. + (resume): Likewise. + * java/lang/Thread.java (setDaemon): Call checkAccess. + +Thu Aug 27 12:24:40 1998 Tom Tromey + + * java/lang/Runtime.java: Rewrote from scratch. + * java/lang/natRuntime.cc: Rewrote from scratch. + + * nogc.cc (JvPrivGCTotalMemory): New function. + (JvPrivGCFreeMemory): Likewise. + (total): New global. + (JvPrivAllocObj): Increment total. + (JvPrivAllocArray): Likewise. + (JvPrivAllocBytes): Likewise. + * include/jvm.h: Declare JvPrivGCTotalMemory, JvPrivGCFreeMemory. + * boehm.cc (JvPrivGCTotalMemory): New function. + (sum_blocks): Likewise. + (JvPrivGCFreeMemory): Likewise. + +Wed Aug 26 12:30:32 1998 Tom Tromey + + * include/javaprims.h (java::lang): Added FirstThread. + * java/lang/natFirstThread.cc: New file. + * java/lang/FirstThread.java: New file. + * prims.cc (main_signature): Removed. + (main_name): Removed. + #include FirstThread.h. + * Makefile.in: Rebuilt. + * Makefile.am (TFRIEND): Removed. + (java/lang/Thread.h): Likewise. + (FTFRIEND): New macro. + (java/lang/FirstThread.h): New target. + (nat_files): Added natFirstThread.o. + (nat_headers): Added FirstThread.h. + * include/jvm.h (_Jv_StartFirstThread): Don't declare. + * java/lang/natThread.cc (_Jv_StartFirstThread): Removed. + + * java/lang/Thread.java (setName): Throw IllegalArgumentException + if name is null. + (Thread): Likewise. + + * java/lang/natThread.cc (start): Synchronize the thread. + (stop): Synchronize the thread. + + * java/lang/ThreadDeath.java: Rewrote from scratch. + + * Makefile.in: Rebuilt. + * Makefile.am (TGFRIEND): New macro. + (java/lang/ThreadGroup.h): New target. + ($(nat_files) prims.o boehm.o nogc.o): Native files depend on the + native headers. + ($(javao_files) $(nat_files) prims.o boehm.o nogc.o): Removed. + + * nogc.cc: Include config.h. + + * java/lang/ThreadGroup.java: Rewrote from scratch. + +Tue Aug 25 00:12:54 1998 Tom Tromey + + * java/lang/Thread.java (checkAccess): Only call in to security + manager if it exists. + (Thread): Don't check access when creating the first thread. Add + this thread to the appropriate ThreadGroup. + + * java/lang/natThread.cc (run_): Call uncaughtException method on + the ThreadGroup. + + * java/lang/Runnable.java: Rewrote from scratch. + * java/lang/Thread.java: Updated copyright comment to correct + form. + +Wed Aug 26 15:16:18 1998 Warren Levy + + * java/util/Random.java: Rewritten. + +Wed Aug 26 14:25:39 1998 Alexandre Petit-Bianco + + * prims.cc (_Jv_NewMultiArray): Need one more slot to store + trailing 0 in array[]. + +Wed Aug 26 12:21:06 1998 Anthony Green + + * Makefile.am (AM_MAKEFLAGS): Remove RUNTEST, EXPECT, + and RUNTESTFLAGS from AM_MAKEFLAGS. + (SUBDIRS): Conditionally include testsuite. + * Makefile.in: Rebuilt. + +Tue Aug 25 18:14:53 1998 Anthony Green + + * java/lang/Object.h: Include java-assert.h. + +Tue Aug 25 17:33:57 1998 Anthony Green + + * Makefile.am: Add testsuite directory. + * configure.in: Build testsuite/Makefile. + * Makefile.in, configure: Rebuilt. + +Tue Aug 25 00:12:54 1998 Tom Tromey + + * prims.cc (JvRunMain): Use _Jv_StartFirstThread. + * include/jvm.h (_Jv_StartFirstThread): Declare. + + * include/javaprims.h (java::lang): Added Exception, + RuntimeException. + + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added NullPointerException.h, + InterruptedException.h, IllegalArgumentException.h, Exception.h, + Throwable.h, RuntimeException.h, IllegalThreadStateException.h. + (java/lang/Thread.h): New target. + (TFRIEND): New macro + + * include/java-assert.h (JvFail): Use 0 and not NULL. + + * posix-threads.cc (JvPrivThreadStart): Use getPriority() method + instead of assuming we are a friend of Thread. + * quick-threads.cc (JvPrivThreadStart): Use isDaemon() method + instead of assuming we are a friend of Thread. + +Mon Aug 24 15:58:36 1998 Tom Tromey + + * java/lang/natThread.cc: Rewrote from scratch. + * java/lang/Thread.java: Rewrote from scratch. + * prims.cc (JvRunMain): Use new Thread constructor. + * include/javaprims.h (java::lang): Added InterruptedException. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added java/lang/Thread.h. + * java/lang/Thread.h: Removed. + * quick-threads.cc (JvPrivThreadStart): Added `data' argument. + * no-threads.cc (JvPrivThreadStart): Added JvPrivThread_t + argument. + * posix-threads.cc (JvPrivThreadJoin): Removed. + (JvPrivThreadInitData): Don't initialize join_mutex or join_cond. + (really_start): Don't notify join_cond. + (JvPrivThreadStart): Added `data' argument. + * include/no-threads.h (JvPrivThreadInterrupt): Removed. + (JvPrivThreadJoin): Likewise. + Use JvFail instead of sorry. + (JvPrivThreadSuspend): Removed. + (JvPrivThreadResume): Removed. + * include/quick-threads.h (JvPrivThreadInterrupt): Removed. + (JvPrivThreadJoin): Likewise. + (JvPrivThreadSuspend): Use JvFail. + (JvPrivThreadResume): Likewise. + (JvPrivThreadSuspend): Removed. + (JvPrivThreadResume): Likewise. + * include/posix-threads.h (JvPrivThreadInterrupt): Removed. + (JvPrivThread_t): Removed join_mutex, join_cond. + Use JvFail instead of sorry. + (JvPrivThreadSuspend): Removed. + (JvPrivThreadResume): Likewise. + +Tue Aug 25 12:50:13 1998 Warren Levy + + * java/util/Observer.java: Rewritten + * java/util/Enumeration.java: Rewritten + +Tue Aug 25 11:33:54 1998 Warren Levy + + * java/util/StringTokenizer.java: Rewritten + * java/util/Stack.java: Added COPYRIGHT-TBD comment + * java/util/Vector.java: Added COPYRIGHT-TBD comment + * java/io/Serializable.java: Added COPYRIGHT-TBD comment + +Fri Aug 21 10:14:22 1998 Tom Tromey + + * include/java-assert.h (JvFail): Call _Jv_Abort even when DEBUG + not defined. + + * no-threads.cc (JvPrivThreadStart): Use JvAssert. + Include java-assert.h. + * include/java-assert.h: New file. + * prims.cc (_Jv_Abort): New function. + Include java-assert.h, not assert.h. + (_Jv_MonitorExit): Use JvAssert. + (resolveConstants): Likewise. + (processClass): Likewise. + (JvRunMain): Assert that method is found. + + * configure: Rebuilt. + * configure.in: Check for test subdir. + * Makefile.in: Rebuilt. + * Makefile.am (SUBDIRS): Conditional on TESTSUBDIR. + + * prims.cc (JvRunMain): Use NORM_PRIORITY. + * java/lang/Thread.h (Thread): Added NORM_PRIORITY. + + * prims.cc (resolveConstants): Removed unused variables. + (processClass): Likewise. + + * include/quick-threads.h (JvPrivThreadCurrent): Use + coop_getspecific. + * quick-threads.cc (destroy_data): New function. + (JvPrivInitThreads): Create key. + (JvPrivThreadKey): New global. + (JvPrivThreadStart): Use coop_setspecific. + + * include/quick-threads.h, include/posix-threads.h, + include/no-threads.h, no-threads.cc, quick-threads.cc, + posix-threads.cc, nogc.cc, boehm.cc: Added copyright comment. + +Thu Aug 20 10:57:30 1998 Tom Tromey + + * include/no-threads.h (JvPrivThreadInitData): Don't set + JvPrivOnlyThread. + + * include/quick-threads.h (JvPrivCondWait): coop function now + takes microseconds. + (JvPrivThreadJoin): Likewise. + + * java/lang/Thread.h (Thread): Updated declaration of + JvPrivThreadStart. + * include/quick-threads.h, include/posix-threads.h: Updated + declaration of JvPrivThreadStart. + * include/no-threads.h (JvPrivThreadStart): Changed definition + into declaration. + * no-threads.cc (JvPrivThreadStart): Removed `data' argument. + * quick-threads.cc (JvPrivThreadStart): Removed `data' argument. + * posix-threads.cc (JvPrivThreadStart): Removed `data' argument. + +Wed Aug 19 14:53:59 1998 Tom Tromey + + * quick-threads.cc (qthrow): New function. + (JvPrivInitThreads): New function. + (started): New global. + (JvPrivThreadStart): Call coop_start if required. + * include/quick-threads.h (JvPrivThreadCancel): Implement. + (JvPrivThreadDestroy): Likewise. + (JvPrivInitThreads): Removed. + * include/posix-threads.h (JvPrivThreadCancel): Added error + argument. + * java/lang/natThread.cc (stop_): Pass exception to + JvPrivThreadCancel. + +Tue Aug 18 12:58:22 1998 Tom Tromey + + * include/javaprims.h (java::lang): Added + IllegalArgumentException, IllegalThreadStateException, Math, + NullPointerException, ThreadDeath. + (java::util): Added Enumeration. + + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added java/lang/ThreadGroup.h. + + * java/lang/ThreadGroup.java (ThreadGroup): No-args constructor + now public. + (threadsv): Renamed from threads to avoid clash in C++ header. + (groupsv): Likewise. + * include/no-threads.h (JvPrivThreadStart): Removed. + * no-threads.cc (JvPrivThreadStart): New function. + * java/lang/Thread.java (Thread): New constructor for internal use. + * java/lang/Thread.h (Thread): Declare JvRunMain as friend. + (Thread): Declare constructor. + * prims.cc (JvRunMain): Create the initial Thread and + ThreadGroup. + Include and . + * posix-threads.cc (JvPrivThreadStart): Added `thread' argument. + Removed `daemon' argument. + + * prims.cc (JvRunMain): Call _Jv_InitializeSyncMutex. + * java/lang/Object.h (Object): Declare _Jv_InitializeSyncMutex as + a friend. + * java/lang/natObject.cc (_Jv_InitializeSyncMutex): New function. + + * Makefile.in: Rebuilt. + * Makefile.am (INCLUDES): Include THREADINCS. + + * configure: Rebuilt. + * configure.in: Recognize `qt' as a threads package. + +Thu Aug 20 12:42:32 1998 Warren Levy + + * java/util/Stack.java (pop): Null out topmost node for robustness. + +Thu Aug 20 12:30:30 1998 Warren Levy + + * java/util/Stack.java: Rewritten. + * java/util/Vector.java (isEmpty): Simplified expression. + +Wed Aug 19 18:02:19 1998 Warren Levy + + * prims.cc (_Jv_NewObjectArray): Renamed from JvNewObjectArray. + (soft_anewarray): Removed, _Jv_NewObjectArray used instead. + + * include/java-array.h (JvNewObjectArray): Created inline to + _Jv_NewObjectArray. + + * java/lang/Class.h (_Jv_NewObjectArray): Renamed from + JvNewObjectArray. + +Wed Aug 19 14:12:02 1998 Warren Levy + + * java/util/Vector.java: Rewritten. + * java/io/Serializable.java: Created. + +Fri Aug 14 10:31:54 1998 Tom Tromey + + * java/lang/Float.java (NEGATIVE_INFINITY, POSITIVE_INFINITY): + Infinity is 1/0, not 1/1. + + * boehm.cc (JvPrivAllocArray): Use GC_generic_malloc. + + * configure: Rebuilt. + * configure.in: Removed duplicate AC_ARG_WITH. + +Thu Aug 13 14:51:47 1998 Warren Levy + + * prims.cc (_Jv_ThrowBadArrayIndex): Renamed from + soft_badarrayindex. + (_Jv_InitClass): Renamed from soft_initialise_class. + (_Jv_NewMultiArray): Renamed from soft_multianewarray. + (_Jv_CheckCast): Renamed from soft_checkcast. + (_Jv_LookupInterfaceMethod): Renamed from soft_lookupinterfacemethod. + (_Jv_CheckArrayStore): Renamed from soft_checkarraystore. + (JvRunMain): Call JvInitClass instead of soft_initialise_class. + * include/cni.h (JvInitClass): New function. + (_Jv_InitClass): Renamed from soft_initialise_class. + +Wed Aug 12 10:07:04 1998 Tom Tromey + + * configure: Rebuilt. + * configure.in (CXX): Don't set. + * Makefile.in: Rebuilt. + * Makefile.am (AM_CXXFLAGS): New macro. + + * Makefile.in: Rebuilt. + * Makefile.am ($(javao_files) $(nat_files) prims.o boehm.o + nogc.o): New target. + + * boehm.cc (mark_obj): Update PUSH_CONTENTS call for new Boehm + GC. + (mark_array): Likewise. + +Tue Aug 11 11:44:53 1998 Per Bothner + + * java/lang/Class.h (JvMethod): Removed some unused fields. + (JvField.info): Removed unused idx union variant. + +Mon Aug 10 15:00:14 1998 Tom Tromey + + * prims.cc (makeUtf8Const): Mask off high bits of hash value to + match compiler. + +Mon Aug 3 16:13:54 1998 Per Bothner + + * configure.in, configure (CXX): Add -fvtable-thunks. + +Thu Jul 30 14:34:47 1998 Per Bothner + + * java/lang/Object.java (finalize): Move first. + * java/lang/Object.h (_JvObjectPrefix): New dummy base class. + (Object): Re-arrange order to match Object.java. + +Tue Jul 28 21:42:16 1998 Per Bothner + + * prims.cc (hashUtf8String): Fix - use new JavaSoft specification. + * java/lang/natString.cc (hashChars): Likewise. + + * prims.cc (RuntimeClass): New macro. + (JvRunMain): Do soft_initialise_class of RuntimeClass before exit. + +Mon Jul 27 22:20:10 1998 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (AM_MAKEFLAGS): New macro. + +Fri Jul 24 11:21:24 1998 Tom Tromey + + * nogc.cc: Include . + + * Makefile.in: Rebuilt. + * Makefile.am (GJAVAH): gjavah no longer in java subdir. + +Thu Jul 23 11:38:40 1998 Tom Tromey + + * exception.cc (terminate): Removed. + (unexpected): Removed. + + * configure: Rebuilt. + * configure.in: Handle case where target subdir is ".". + + * configure: Rebuilt. + * configure.in: Compute COMPPATH based on --with-target-subdir + option. Added --with-target-subdir and --with-cross-host. Use + --with-cross-host to determine when a cross compiler is in use. + + * Makefile.in: Rebuilt. + * Makefile.am (GJAVAH): Include COMPPATH. + * configure: Rebuilt. + * configure.in: Subst COMPPATH. + +Mon Jul 20 16:13:43 1998 Tom Tromey + + * prims.cc (lockMutex): Removed. + (unlockMutex): Likewise. + (processClass): Lock the class using a JvSynchronize object. + +Fri Jul 17 11:27:48 1998 Tom Tromey + + * java/lang/natString.cc (gc_calloc_fixed): Removed. + (gc_free_fixed): Removed. + (rehash): Use JvPrivAllocBytes, not gc_calloc_fixed; don't bother + freeing old value of strhash. + + * exception.cc (_Jv_type_matcher): Cast first argument to + _Jv_IsInstanceOf. + +Thu Jul 16 14:51:44 1998 Tom Tromey + + * include/java-array.h (jstringArray): New type. + * java/lang/natSystem.cc (setProperty): Removed. + (initProperties): Directly call JvNewStringLatin1 for arguments. + * java/util/natDate.cc: Include java/util/Date.h, not + java-util.h. + (setTime): Removed. + * java/io/FileDescriptor.java (available): No longer static. + * java/lang/natDouble.cc (Double): Removed class definition. + * include/javaprims.h (java::lang::Number): Declare. + (java::lang::NumberFormatException): Likewise. + (java::io::FilenameFilter): Likewise. + (java::lang::Character): Likewise. + (java::lang::Error): Likewise. + (java::lang::SecurityManager): Likewise. + (java::util::Vector): Likewise. + (java::io::FileNotFoundException): Likewise. + (java::io::IOException): Likewise. + (java::lang::NativeLang): Likewise. + (java::lang::UnsatisfiedLinkError): Likewise. + (java::util::StringTokenizer): Likewise. + (java::io::InputStream, java::io::OutputStream): Likewise. + (java::io::PrintStream, java::lang::SecurityException): Likewise. + (java::util::Hashtable): Likewise. + * Makefile.in: Rebuilt. + * Makefile.am (nat_headers): Added java/lang/Double.h, + java/lang/Number.h, java/lang/System.h, java/lang/Runtime.h. + (MOSTLYCLEANFILES): Added nat_headers. + * include/jvm.h: Moved many defines, declarations, and functions + to java/lang/Class.h. + (struct JvSyncInfo): Moved to java/lang/Object.h. + (UTF8_GET): Moved to java/lang/String.h. + +Wed Jul 15 09:02:31 1998 Tom Tromey + + * java/io/io-defs.h: Don't include java-io.h. + * include/java-io.h: Removed. + * include/javaprims.h: Include java::io. + +Tue Jul 14 17:04:26 1998 Tom Tromey + + * include/java-io.h (File): Removed + (FileDescriptor): Likewise. + + * java/io/io-defs.h: Include java/io/File.h and + java/io/FileDescriptor.h. + + * Makefile.in: Rebuilt. + * Makefile.am (GJAVAH): New macro. + (.class.h): New rule. + (SUFFIXES): Added .h. + (nat_headers): New macro. + ($(nat_headers)): New target. + (BUILT_SOURCES): Added nat_headers. + + * include/java-util.h: Removed. + +Fri Jul 3 10:17:14 1998 Tom Tromey + + * include/java-io.h: Changed to avoid java-lang.h. + * java/lang/natThread.cc: Include java/lang/Thread.h, not + java-lang.h. + * java/lang/natSystem.cc: Include java/lang/System.h, not + java-lang.h. + * java/lang/natString.cc: Include java/lang/String.h, not + java-lang.h. + * java/lang/natRuntime.cc: Include java/lang/Runtime.h, not + java-lang.h. + * java/lang/natClass.cc: Include java/lang/Class.h, not + java-lang.h. + * java/lang/natDouble.cc: Include java/lang/Object.h, not + java-lang.h. + * java/lang/natObject.cc: Include java/lang/Object.h, not + java-lang.h. + * exception.cc: Don't include java-lang.h. + * posix-threads.cc: Include java/lang/Thread.h, not java-lang.h. + * no-threads.cc: Include java/lang/Thread.h, not java-lang.h. + * nogc.cc: Don't include java-lang.h. + * boehm.cc: Include java/lang/Class.h, not java-lang.h. + * prims.cc (processClass): Don't use `init_type'; just cast to + type directly. + Include java/lang/Class.h and jvm.h, not java-lang.h. + (JvAllocObject): Wrote single-argument version. + (PrimClass): Inherit from Class. + (initPrimClass): Removed. + * include/java-lang.h: Removed. + * include/jvm.h: Declare struct _dispatchTable. + * include/cni.h: Don't declare _Jv_MonitorEnter, + _Jv_MonitorExit, struct _dispatchTable. + * include/javaprims.h: Moved all typedefs here, from cni.h. + * java/lang/Class.h: New file. + * include/java-array.h: New file. + * java/lang/Object.h: New file. + + * prims.cc (classFromSig): Now static. + +Wed Jul 1 12:28:48 1998 Tom Tromey + + * include/cni.h: Don't mention soft_new. + * include/java-lang.h (Object): Don't mention soft_new. Mention + _Jv_NewPrimArray, not newPrimArray. + * prims.cc (soft_new): Removed. + (_Jv_NewArray): Renamed from soft_newarray. + (soft_anewarray): Use JvNewObjectArray. + (newArray): Likewise. + (newRefArray): Removed. + (_Jv_NewPrimArray): Renamed from newPrimArray. + (equalUtf8Consts): Now static. + (soft_instanceof): Removed. + * java/lang/natDouble.cc (doubleToString): Now static. + + * java/lang/natDouble.cc (java_lang_Double_doubleToLongBits, + java_lang_Double_longBitsToDouble, java_lang_Double_toString): + Removed. + +Tue Jun 30 10:54:57 1998 Tom Tromey + + * include/java-lang.h: Renamed functions to _Jv_MonitorEnter and + _Jv_MonitorExit. + * include/cni.h: Renamed functions to _Jv_MonitorEnter and + _Jv_MonitorExit. + * include/no-threads.h (JvPrivMutexLock): Always return -1. + (JvPrivMutexUnlock): Likewise. + * prims.cc (_Jv_MonitorEnter): Renamed from soft_monitorenter. + Return value now jint. + (_Jv_MonitorExit): Renamed from soft_monitorexit. Return value + now jint. + + * Makefile.in: Rebuilt. + * Makefile.am: Don't allow `jV' names. + (maintainer-check): Depend on libjava.a. + * exception.cc (_Jv_eh_free): Renamed from __jV_eh_free. + + * Makefile.in: Rebuilt. + * Makefile.am (NM): New macro. + (maintainer-check): New target. + + * include/posix-threads.h (_MIT_POSIX_THREADS): Removed. + + * configure: Rebuilt. + * configure.in: Use --enable-threads, not --enable-gc. Fix + documentation for --enable-threads. Changed option to work like + identical option in gcc/configure. + +Mon Jun 29 10:44:29 1998 Tom Tromey + + * boehm.cc (mark_array): Use JvGetArrayLength. + +Thu Jun 25 11:56:21 1998 Per Bothner + + * exception.cc: New file (mostly written by Andrew MacLeod), + exception handling support. + * Makefile.am (libjava_a_SOURCES), Makefile.in: Add exception.cc. + Remove -fexceptions - it is now the default. + + * prims.cc (JvIsInstanceOf): Renamed to _Jv_IsInstanceOf. + (JvAllocObject): Renamed to _Jv_AllocObject. + (soft_athrow): Removed. Replaced by _Jv_Throw in exception.cc. + (loadClass): Renamed to _Jv_FindClass. + * include/cni.h (JvIsInstanceOf, JvAllocObject). Make into + inline methods that call _Jv_IsInstanceOf and _Jv_AllocObject. + * include/java-lang.h (JvGetArrayLength): New CNI function. + * include/jvm.h (_Jv_FindClass): Added declaration. + + * java/lang/natString.cc: More implementation if COMPACT_STRINGS. + +Wed Jun 24 16:41:30 1998 Per Bothner + + * java/lang/natClass.cc (getName): Add implementation. + * java/lang/Throwable.java (printStackTrace): Handle missing backtrace. + +Tue Jun 23 15:56:24 1998 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (.class.o): Added -fexceptions. + +Mon Jun 15 14:54:06 1998 Tom Tromey + + * configure: Rebuilt. + * configure.in: Don't check for __nanosleep. + * posix-threads.cc (nanosleep): Never define. + +Sun Jun 14 22:37:23 1998 Tom Tromey + + * posix-threads.cc (JvPrivCondWait): Fixed computation of + timespec. + +Thu Jun 11 10:51:44 1998 Tom Tromey + + * java/lang/natThread.cc (enumerate): Uncommented. + * java/lang/Thread.java (interrupted_): Renamed from `interrupt_'. + (interrupt): Call it. + +Wed Jun 10 15:57:16 1998 Tom Tromey + + * configure: Rebuilt. + * configure.in (GCLIBS): Use `-lgc' so gjavac can recognize it. + +Mon Jun 8 12:04:11 1998 Tom Tromey + + * include/no-threads.h (JvPrivThreadInterrupt): New method. + * include/java-lang.h (Thread): Added `interrupted_' method. + * java/lang/Thread.java (interrupted_): New method. + * java/lang/natThread.cc (join): Possibly throw interrupted + exception after join finishes. + (interrupted_): New method. + * posix-threads.cc (JvPrivThreadInitData): Initialize join_mutex, + join_cond. + (JvPrivThreadJoin): New function. + (really_start): Notify all threads waiting for this thread. + (struct starter): Added `data' member. + (JvPrivThreadStart): Set it. + * include/posix-threads.h (JvPrivThread_t): Added join_mutex, + join_cond. + (JvPrivThreadJoin): No longer inline. + (JvPrivThreadInterrupt): New function. + + * include/no-threads.h (JvPrivThreadSleep): Removed. + * posix-threads.cc (JvPrivThreadSleep): Removed. + +Fri Jun 5 13:51:25 1998 Tom Tromey + + * configure: Rebuilt. + * configure.in (THREADOBJS): Initialize to no-threads.o in + no-threads case. + * posix-threads.cc (key): New global. + (JvPrivInitThreads): New function. + (really_start): Set thread-specific data to point to object. + (JvPrivThreadStart): Added `daemon' argument. + (JvPrivThreadSleep): Added `data' argument. + * include/posix-threads.h (JvPrivInitThreads): Removed + implementation. + (JvPrivThreadCurrent): New function. + * include/no-threads.h (JvPrivThreadInitData): Initialize + JvPrivOnlyThread. Added `thread' argument. + (JvPrivThreadCurrent): New function. + (JvPrivThreadStart): Added `daemon' argument. + * no-threads.cc: New file. + * java/lang/natThread.cc (init_data): New function. + (isAlive): Removed. + (start): Set `alive' member. + (stop_): Clear `alive' member. + (destroy): Likewise. + (currentThread): Implemented. + (start): Pass `daemon' argument to JvPrivThreadStart. + (sleep): Rewrote. + * include/java-lang.h (Thread): Added `alive', `tsync' members. + (Thread): Added `init_data' method. + * java/lang/Thread.java (alive, data): New instance variables. + (init_data): New private method. + (isAlive): No longer native. + +Thu Jun 4 14:09:32 1998 Tom Tromey + + * include/java-lang.h (JvRunMain): Declare. + * include/jvm.h (JvPrivInitGC): Revert to C++ linkage. + * prims.cc (JvRunMain): New function. + (main_signature, main_name): New globals. + + * boehm.cc (mark_array): Use `elements' function and not + operator[] on jarray. + + * posix-threads.cc: Include . Define nanosleep if + required. + + * configure: Rebuilt. + * configure.in: Check for _nanosleep. + + * configure: Rebuilt. + * configure.in: Check for pthread_mutexattr_settype. + + * include/cni.h (class JvSynchronize): New class. + * java/lang/Thread.java (sleep): Throws InterruptedException. + (join): Throws InterruptedException. + (resume): Not native. + (resume_): New method. + (start): Now synchronized. + (stop_): New method. + (Thread): Synchronize when accessing threadNumber. + (misc): Removed. + * java/lang/natThread.cc (throwException): New macro. + (sleep): Throw InterruptedException. + (resume_): Renamed. + (stop_): Renamed. + * include/java-lang.h (Runtime): Added interrupted(). + + * boehm.cc (call_finalizer): Correctly initialize jobj. + * include/java-lang.h (Runtime): Added getRuntime() and exit(). + + * java/lang/natSystem.cc (currentTimeMillis): Use #elif, not + `#elseif'. + + * configure: Rebuilt. + * configure.in: Added support for --disable-threads. + * include/no-threads.h: New file. + + * acconfig.h (HAVE_PTHREAD_MUTEXATTR_INIT): New macro. + + * Makefile.in: Rebuilt. + * Makefile.am (EXTRA_libjava_a_SOURCES): Added posix-threads.cc. + (libjava_a_DEPENDENCIES): Added THREADOBJS. + (libjava_a_LIBADD): Added THREADOBJS. + * configure: Rebuilt. + * configure.in: Added --with-threads option. + * posix-threads.cc: New file. + * include/posix-threads.h: New file. + * include/java-lang.h (Object): Added static member sync_mutex, + member sync_info, method init_mutex. + (struct JvSyncInfo): New struct. + Include "java-threads.h". + * prims.cc (soft_monitorenter): Wrote. + (soft_monitorexit): Likewise. + * java/lang/natObject.cc (init_mutex): New method. + (notify): Wrote. + (notifyAll): Wrote. + (wait): Wrote. + (sync_mutex): Define. + Include "java-threads.h". + +Tue Jun 2 15:24:33 1998 Per Bothner + + * include/java-lang.h (JvPrivInitGC): Make extern "C". + * include/jvm.h (JvConvertArgv, JvNewObjectArray): Likewise. + +Mon Jun 1 11:21:34 1998 Per Bothner + + * include/cni.h (jbyte etc): Re-define using __java_byte etc. + Added extern "Java" in places to tell G++ Object is a "Java" type. + Other minor renaming and fixes. + * include/java-io.h (FileDescriptor): Add friend class declarations. + G++ no longer allows non-Java types in method parameters and results + of Java classes. Converted most offending methods to friends. + * java/lang/natDouble.cc (Double::toString): Rename to doubleToString. + * java/lang/natSystem.cc (setProperty): Make friend. + * java/lang/natString.cc, include/java-lang.h (String): Rename + methods findInternSlot to __JvStringFindSlot and __JvStringGetSlot. + * include/java-lang.h (JArray): Remove getData and eoprator[]. + Add elements friend function instead. + * java/lang/natSystem.cc (arraycopy): Use elements function. + * java/io/natFileDescriptor.cc (read, write): Likewise. + * include/java-lang.h (Object): Remove unused make method. + (System::setProperty(char*,char*)): Turn into friend function. + (Class): Rename newObject by JvAllocObject. + * prims.cc: Update to use JvAllocObject, and elements. + + * java/lang/natDouble.cc: Fix double -> jdouble. + +Wed May 20 16:50:06 1998 Per Bothner + + * Makefile.am (INCLUDES): Add -Iinclude (to get config.h). + +Mon May 18 13:46:02 1998 Tom Tromey + + * java/lang/natRuntime.cc (finalize_on_exit): Define. + * include/java-lang.h (Runtime): finalize_on_exit and + runFinalizersOnExit now static. + * java/lang/Runtime.java (runFinalizersOnExit): Now static, to + match JDK 1.2b3. + (finalize_on_exit): Now static. + + * boehm.cc (mark_obj): Get class using getClass() method on + object. + (_dispatchTable): Removed. + +Mon May 11 15:26:52 1998 Tom Tromey + + * java/io/natFileDescriptor.cc (open_read): Only call open if + HAVE_OPEN defined. + (open_write): Likewise. + + * Makefile.in: Rebuilt. + * Makefile.am ($(nat_files)): Depend on config.h. + +Thu May 7 16:22:00 1998 Tom Tromey + + * prims.cc (ObjectClass): Now a macro; updated for new class name + mangling scheme. + (StringClass): Likewise. + (ClassClass): Likewise. + +Wed May 6 00:26:44 1998 Tom Tromey + + * java/io/natFileDescriptor.cc (available): Do nothing unless + HAVE_SELECT defined. + * java/util/natDate.cc (setTime): Conditional on + HAVE_GETTIMEOFDAY. + (toString): Conditional on HAVE_TIME. + * aclocal.m4, configure: Rebuilt. + * acinclude.m4: New file. + * configure.in: Don't actually call AM_EXEEXT. Call + AC_CANONICAL_HOST. Use LIB_AC_PROG_CC and LIB_AC_PROG_CXX. Added + --with-target-subdir option. Check for select and open + functions. + +Tue May 5 00:10:45 1998 Tom Tromey + + * boehm.cc (JvPrivRegisterFinalizer): Changed interface. + (call_finalizer): Likewise. + * nogc.cc (JvPrivRegisterFinalizer): Changed interface. + * prims.cc (newObject): Pass actual method pointer to + JvPrivRegisterFinalizer. + * include/jvm.h (JvPrivFinalizerFunc): New typedef. + (JvPrivRegisterFinalizer): Changed interface. + + * Makefile.in: Rebuilt. + * Makefile.am (MOSTLYCLEANFILES): New macro. + (CLEANFILES): Removed javao_files. + +Fri May 1 22:52:24 1998 Tom Tromey + + * nogc.cc: New file. + * Makefile.in: Rebuilt. + * Makefile.am (INCLUDES): Use GCINCS, not paths to boehm-gc. + (EXTRA_libjava_a_SOURCES): New macro. + (libjava_a_SOURCES): Removed boehm.cc. + (libjava_a_DEPENDENCIES): Added GCOBJS. + (libjava_a_LIBADD): Likewise. + * configure: Rebuilt. + * configure.in: Added code for --enable-gc=TYPE. + +Thu Apr 30 14:54:00 1998 Tom Tromey + + * boehm.cc (mark_array): Don't further dereference pointer from + array. + + * boehm.cc: Include , not . + * Makefile.in: Rebuilt. + * Makefile.am (INCLUDES): Removed -I for boehm-gc/include; added + one for boehm-gc build directory. + +Wed Apr 29 09:45:19 1998 Tom Tromey + + * include/java-lang.h (finalize_on_exit): New instance variable in + java::lang::Runtime. + (runFinalizersOnExit): New method. + * java/lang/Runtime.java (finalize_on_exit): New instance + variable. + (runAllFinalizers_): New private method. + (runFinalizersOnExit): New method. + * boehm.cc (JvPrivRunFinalizers): New function. + (JvPrivRunAllFinalizers): Likewise. + (JvPrivRunGC): Likewise. + * java/lang/natRuntime.cc: Include "jvm.h". + (gc): Call JvPrivRunGC. + (runFinalization): Call JvPrivRunFinalizers. + (runFinalizersOnExit): New method. + (exit_): Call JvPrivRunAllFinalizers if required. + * include/jvm.h: Declare JvPrivRunFinalizers, + JvPrivRunAllFinalizers, JvPrivRunGC. + +Tue Apr 28 15:06:50 1998 Tom Tromey + + * boehm.cc (JvPrivRegisterFinalizer): New function. + (call_finalizer): Likewise. + * include/jvm.h: Declare JvPrivRegisterFinalizer. + * prims.cc (finalize_name): New global. + (newObject): Just call other newObject. + (newObject): Register finalizer if it exists. + +Mon Apr 27 12:47:03 1998 Tom Tromey + + * prims.cc (gc_malloc): Removed. + (makeUtf8Const): Use JvPrivAllocBytes. + (lookupArray): Likewise. + (newPrimArray): Likewise. + (JvNewObjectArray): Use JvPrivAllocArray. + (newObject): Use JvPrivAllocObj. + (newObject): Likewise. + Changed Method -> JvMethod everywhere. + Changed Field -> JvField everywhere. + * include/java-lang.h (Object): Changed type of `fields' to + JvField*. + (jmethodID, jfieldID): New typedefs. + (Object): JvGetFirstInstanceField and JvNumInstanceFields now + friends. + * include/jvm.h (struct JvMethod): Renamed from Method, and moved + from java-lang.h. + (METHOD_NATIVECODE): Moved from java-lang.h. + (class JvField): New class. + (JvGetFirstInstanceField): New function. + (JvFieldIsRef): Likewise. + (JvGetObjectField): Likewise. + (JvNumInstanceFields): Likewise. + +Thu Apr 23 16:42:11 1998 Tom Tromey + + * boehm.cc: New file. + * Makefile.in: Rebuilt. + * Makefile.am (libjava_a_SOURCES): Added boehm.cc. + (INCLUDES): Added -I options to find boehm-gc files. + +Wed Apr 29 15:11:37 1998 Tom Tromey + + * configure: Rebuilt. + * configure.in (CXX): Put -fno-rtti here and not in CXXFLAGS. + + * Makefile.in: Rebuilt. + * Makefile.am (nat_files): New macro. + (libjava_a_DEPENDENCIES): Use it. + (libjava_a_LIBADD): Likewise. + ($(nat_files)): New static pattern rule. + (class_files): Run separate find to find .class files. + (javao_files): Compute based on class_files. + (BUILT_SOURCES): New macro. + +Thu Apr 23 16:42:11 1998 Tom Tromey + + * Makefile.am (java_files): New macro. + (class_files): Likewise. + (javao_files): Likewise. + (libjava_a_DEPENDENCIES): Include $(javao_files). + (libjava_a_LIBADD): Likewise. + (classes.stamp): Depend on $(java_files); only recompile changed + files. + (here): New macro. + (CLEANFILES): Don't run find; use macros. Don't mention + libjava.a. + (.class.o): New target. + (compiled.stamp): Removed. + +Thu Apr 23 14:17:43 1998 Per Bothner + + * java/io/{Reader,InputStreamReader,FileReader,BufferedReader, + LineNumberReader}>java: Newly-implemented standard classes. + +Thu Apr 23 14:02:04 1998 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (compiled.stamp): Use $(CC), not $(GCC). + + * Makefile.in: Rebuilt. + * Makefile.am (hack): New macro. + (libjava_a_LIBADD): Use $(hack) to work around automake oddity. + +Wed Apr 22 16:49:57 1998 Tom Tromey + + * include/config.h.in: New file. + * include/config.h: Removed. + * acconfig.h: New file. + * Makefile.am (AR, ARFLAGS, JAVAC, GCC, CXX, CXXFLAGS): Removed. + (lib_LIBRARIES, libjava_a_SOURCES, libjava_a_DEPENDENCIES, + libjava_a_LIBADD): New macros. + (INCLUDES): New macro. + (prims.o): Removed. + (.cc.o): Removed. + (SUFFIXES): Removed. + (all): Removed. + (libjava.a): Removed. + + * configure: Rebuilt. + * configure.in: Call AC_PROG_CC, AC_PROG_CXX, AC_PROG_RANLIB. + Look for headers and functions we require. Create + include/config.h. + +Mon Apr 20 22:25:00 1998 Per Bothner + + * prims.cc (instance_class, instanceof, JvIsInstanceOf, JvConvertArgv, + soft_instanceof, newObject, JbNewObjectArray, soft_checkcast, + soft_lookupinterfacemethod): New functions. + (PrimClass): Actually initialize the primitive classes. + (Utf8Const2JavaString): Moved to java/lang/natString.cc. + + * include/java-util.h: Removed java::util definition. + * include/cni.h: Moved java::util here and added Properties. + Added more function prototypes. + * include/java-lang.h: Added mroe methods and friend declarations. + * include/config.h (HAVE_GETTIMEOFDAY, HAVE_TIME): Added. + * include/jvm.h (strLengthUtf8): Add declaration. + + * java/lang/{Integer,Long,Boolean,Character,Float,Double}.java (TYPE): + New static field. + * java/lang/{Byte,Short,Void}.java: New classes. + * java/lang/Character.java (isJavaIdentifierStart, + JavaIdentifierPart): New static methods. + * java/lang/Number.java (byteValue, shortValue): New methods. + + * java/lang/String.java (intern, hashCode): Make native. + * java/lang/natString.cc: New file. Handle the string pool. + * Makefile.am: Build natString.o. Use CXXFLAGS. + + * java/lang/Class.java (isArray, isPrimitive, getComponentType, + isInstance, isAssignableFrom), java/lang/natClass.cc: New methods. + * java/lang/Throwable.java (): Don't fillInStackTrace yet. + * java/lang/System.java (setProperty): New private method. + (initProperties): Take argument, and make native. + * java/lang/natSystem.cc: Implement (preliminary) initProperties. + (currentTimeMillis): Make more robust. + + * java/io/{Writer,PrintWriter,OutputStreamWriter}.java: New classes. + * java/io/UnsupportedEncodingException.java: New exception class. + + * java/io/DataInputStream.java: Don't use a PushbackInputStream. + * java/io/FilterOutputStream.java: Add missing 'extends OutputStream'. + +Fri Apr 10 11:52:10 1998 Per Bothner + + * Makefile.am (CXXFLAGS, JC1FLAGS): New macro. + * prims.cc: Added bunch of stuff. + * include/cni.h: Added various definitions. + * include/java-lang.h: Added Method, various friends, some macros. + + * include/config.h: Added HAVA_MEMMOVE and HAVE_MEMCPY. + * java/lang/System.java (arraycopy): Make native. + +Sun Apr 5 23:58:51 1998 Per Bothner + + * java/lang/{netObject.cc,natClass.cc,natDouble.cc,natRuntime.cc, + natSystem.cc,natThread.cc}: Native (C++) methods for various classes. + * java/lang/ClassLoader.java (defineClass): Now takes extra argument. + * java/lang/Double.java (toString, doubleToLongBits, longBitsToDouble): + Make native. + * java/lang/Runtime.java: Declare methods as native instead of + using NativeLang. + * java/lang/SecurityManager.java (getClassContext): Just throw Error. + * java/lang/System.java: Comment out some stuff, for now. + * java/lang/Thread.java: Re-write. Use native methods. + * java/lang/NativeLang.java: Remove most of it. + + * java/util/natDate.cc: Native (C++) methods for Date. + * java/util/{Calendar.java,GregorianCalendar.java}: New classes. + * java/util/Date.java: Complete re-write. + + * java/io/io-defs.h: New header file. + * java/io/FileDescriptor.java: Add a bunch of private methods, + mostly moved from NativeIO.java and natNativeIO.cc. + * java/io/{natFile.cc,java/io/natFileDescriptor.cc}: New native code. + * java/io/File.java: Use new code. + * java/io/{FileInputStream.java.FileOutputStream.java, + RandomAccessFile.java}: Use new private FileDescriptor methods. + * java/io/NativeIO.java: Removed, no longer used. + + * java/io/StreamTokenizer.java (numericChars): Make char array. + + * include/*.h: Various header files used by the C++ native code. + + * Makefile.am, Makefile.in, aclocal.m4, configure, configure.in: + New autoconf+automake-based setup. + * prims.cc: New file for Java "primitives". + diff --git a/libjava/LIBGCJ_LICENSE b/libjava/LIBGCJ_LICENSE new file mode 100644 index 00000000000..3785700f91b --- /dev/null +++ b/libjava/LIBGCJ_LICENSE @@ -0,0 +1,11 @@ +March 2, 1999 + +The libgcj library is licensed under the terms of the GNU Library +General Public License. + +You should have received a copy of the GNU Library General Public +License along with libjava; see the file COPYING.LIB. If not, write +to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, +MA 02111-1307, USA. + + diff --git a/libjava/Makefile.am b/libjava/Makefile.am new file mode 100644 index 00000000000..eed9d2ac600 --- /dev/null +++ b/libjava/Makefile.am @@ -0,0 +1,660 @@ +## Process this file with automake to produce Makefile.in. + +AUTOMAKE_OPTIONS = foreign no-installinfo + +if TESTSUBDIR +SUBDIRS = testsuite +endif + +## ################################################################ + +## +## What gets installed, and where. +## + +toolexecdir = $(exec_prefix)/$(target_alias) +toolexeclibdir = $(toolexecdir)/lib$(MULTISUBDIR) + +toolexeclib_LIBRARIES = libgcj.a +data_DATA = libgcj.zip + +## For now, only on native systems. +if NATIVE +bin_PROGRAMS = jv-convert +endif + +## ################################################################ + +## +## Compilers and compilation flags. +## + +## CANADIAN is a misnomer. Really we check to see if we must pick up +## the tools from the path. +if CANADIAN +if NULL_TARGET +## In this case, gcj is found outside the build tree. However, zip is +## found in the build tree. +GCJ = gcj +ZIP = $(MULTIBUILDTOP)../$(COMPPATH)/zip/zip$(EXEEXT) +else +GCJ = $(target_alias)-gcj +ZIP = zip +endif +GCJH = gcjh +else # CANADIAN +## JAVAC is set to `$(GCJ) -C'. However, JAVAC is run from the srcdir +## (due to problems running it in builddir). In this case the obvious +## definition of GCJ won't work; instead we resort to this ugly +## definition that gives us absolute paths. +expanded = `cd $(MULTIBUILDTOP)../$(COMPPATH)/gcc && pwd` +GCJ = $(expanded)/gcj$(EXEEXT) -B$(expanded)/ +GCJH = $(MULTIBUILDTOP)../$(COMPPATH)/gcc/gcjh$(EXEEXT) +ZIP = $(MULTIBUILDTOP)../$(COMPPATH)/zip/zip$(EXEEXT) +endif # CANADIAN + +JAVAC = $(GCJ) -C + +EH_COMMON_INCLUDE = @EH_COMMON_INCLUDE@ + +WARNINGS = -W -Wall +AM_CXXFLAGS = -fno-rtti -fvtable-thunks @LIBGCJ_CXXFLAGS@ $(WARNINGS) +if USING_GCC +AM_CFLAGS = @LIBGCJ_CFLAGS@ $(WARNINGS) +else +AM_CFLAGS = @LIBGCJ_CFLAGS@ +endif + +JCFLAGS = -g +JC1FLAGS = -g @LIBGCJ_JAVAFLAGS@ + +INCLUDES = -Iinclude -I$(top_srcdir)/include $(GCINCS) $(THREADINCS) $(EH_COMMON_INCLUDE) + + +## ################################################################ + +## +## How to build libgcj.a and libgcj.zip +## + +## Objects from C++ sources in subdirs. +nat_files = $(nat_source_files:.cc=.o) +## Objects from C sources in subdirs. +c_files = $(c_source_files:.c=.o) +## Objects from Java sources in subdirs. +javao_files = $(java_source_files:.java=.o) + +libgcj_a_SOURCES = prims.cc jni.cc exception.cc +EXTRA_libgcj_a_SOURCES = boehm.cc nogc.cc posix-threads.cc no-threads.cc \ + $(c_source_files) $(java_source_files) +libgcj_a_DEPENDENCIES = libgcj.zip $(javao_files) $(nat_files) \ + $(c_files) $(GCOBJS) $(THREADOBJS) +libgcj_a_LIBADD = $(javao_files) $(nat_files) $(c_files) $(GCOBJS) \ + $(THREADOBJS) + +## Make the .class files depend on the .zip file. This seems +## backwards, but is right. This doesn't catch all the .class files, +## but that is ok, because the ones it fails to pick up are defined in +## a .java file with some other class which is caught. Note that we +## only want to create headers for those files which do not have +## hand-maintained headers. +$(java_source_files:.java=.class): libgcj.zip + +## We have the zip file depend on the java sources and not the class +## files, because we don't know the names of all the class files. +## FIXME: this method fails in a peculiar case: if libgcj.zip is +## up-to-date, and foo.class is removed, and bar.java is touched, then +## `make libgcj.zip' will not rebuilt foo.class. That's because +## libgcj.zip is not out-of-date with respect to foo.java. +libgcj.zip: $(java_source_files) +## This little nastiness is here so that the backquoted stuff in the +## GCJ definition can be correctly expanded, if required. + javac="$(JAVAC)"; cd $(srcdir); \ + $$javac $(JCFLAGS) -classpath $(here):`/bin/pwd` -d $(here) \ + $(subst $(srcdir)/,,$?) + -@rm -f libgcj.zip +## Note that we explicitly want to include directory information. + $(ZIP) -r libgcj java -n .class -i '*.class' -i '*/' + +MOSTLYCLEANFILES = $(javao_files) $(nat_files) $(nat_headers) $(c_files) +CLEANFILES = libgcj.zip $(class_files) + +SUFFIXES = .class .java .h + +.class.o: + CLASSPATH=$(here) $(CC) -fassume-compiled $(JC1FLAGS) -c -o $@ $< + +.java.o: + CLASSPATH=$(here) $(GCJ) -fassume-compiled $(JC1FLAGS) -c -o $@ $< + +## This is GNU make specific. For the .o files in subdirs, use a +## special rule. The standard automake rule can't be overridden (this +## is a bug in automake), and it also won't put the .o files into +## subdirs. FIXME. +$(nat_files): %.o: %.cc + $(CXXCOMPILE) -c -o $@ $< + +$(nat_files) $(GCOBJS) $(THREADOBJS) $(libgcj_a_OBJECTS): \ + include/config.h $(nat_headers) + +## FIXME: GNU make. +$(c_files): %.o: %.c + $(COMPILE) -c -o $@ $< + +$(c_files): java/lang/fdlibm.h java/lang/ieeefp.h java/lang/mprec.h + +## FIXME: GNU make. +$(javao_files): %.o: %.java + CLASSPATH=$(here) $(GCJ) -fassume-compiled $(JC1FLAGS) -c -o $@ $< + +## ################################################################ + +## +## How to build header files. +## + +.class.h: +## FIXME: GNU make specific. + $(GCJH) -classpath $(top_builddir) $(basename $<) + +## Header files used when compiling some of the nat* files. +nat_headers = $(ordinary_java_source_files:.java=.h) + +$(nat_headers): libgcj.zip + +## Our internal main program needs to be able to create a FirstThread. +FTFRIEND = void JvRunMain (jclass klass, int argc, const char **argv) +java/lang/FirstThread.h: java/lang/FirstThread.class libgcj.zip + $(GCJH) -classpath $(top_builddir) -friend '$(FTFRIEND);' \ + $(basename $<) + +## ThreadGroup has a special constructor that is used when creating +## the first ThreadGroup. We need to expose this to the main program. +TGFRIEND = void JvRunMain (jclass klass, int argc, const char **argv) +java/lang/ThreadGroup.h: java/lang/ThreadGroup.class libgcj.zip + $(GCJH) -classpath $(top_builddir) -friend '$(TGFRIEND);' \ + $(basename $<) + +java/lang/String.h: java/lang/String.class libgcj.zip + $(GCJH) -classpath $(top_builddir) \ + -friend 'jchar* _Jv_GetStringChars (jstring str);' \ + -friend 'jstring* _Jv_StringFindSlot (jchar*, jint, jint);' \ + -friend 'jstring* _Jv_StringGetSlot (jstring);' \ + -friend 'jstring _Jv_NewStringUtf8Const (_Jv_Utf8Const* str);' \ + -friend 'jstring _Jv_NewStringLatin1 (const char*, jsize);' \ + -friend 'jstring _Jv_AllocString (jsize);' \ + $(basename $<) + +java/lang/reflect/Field.h: java/lang/reflect/Field.class libgcj.zip + $(GCJH) -classpath $(top_builddir) \ + -friend 'jfieldID _Jv_FromReflectedField (java::lang::reflect::Field *);' \ + -friend 'jobject _Jv_JNI_ToReflectedField (_Jv_JNIEnv*, jclass, jfieldID);' \ + -friend 'java::lang::Class;' \ + $(basename $<) + +java/lang/reflect/Method.h: java/lang/reflect/Method.class libgcj.zip + $(GCJH) -classpath $(top_builddir) \ + -friend 'jmethodID _Jv_FromReflectedMethod (java::lang::reflect::Method *);' \ + -friend 'java::lang::Class;' \ + $(basename $<) + + +## ################################################################ + +## +## Additional `check' targets for maintainer convenience. +## + +## This is used for maintainer-check. FIXME: should set from +## configure using AC_CHECK_TOOL. +NM = nm + +## Try to make sure our library doesn't stomp the namespace. +maintainer-check: libgcj.a + $(NM) libgcj.a | grep ' T ' \ +## Anything with `4java' is assumed to be from .java source. + | grep -v '4java' \ +## Anything with Jv is ok. + | grep -v 'Jv' \ +## `terminate' and `unexpected' are part of the runtime. + | grep -v 'terminate__Fv' | grep -v 'unexpected__Fv' + +## This rule can be used to see if the headers are more or less +## correct. +header-check: libgcj.zip $(nat_headers) + rm -f htest.cc; \ + for h in $(nat_headers); do \ + echo "#include \"$$h\"" >> htest.cc; \ + done; \ + $(CXXCOMPILE) -fsyntax-only htest.cc + + +## ################################################################ + +## +## The `jv-convert' program and code to rebuild the converter header +## files. +## + +## it only makes sense to try to rebuild the JIS .h files on native +## systems. +if NATIVE +if MAINTAINER_MODE +noinst_PROGRAMS = gen-from-JIS +endif +endif + +CONVERT_DIR = gnu/gcj/convert + +jv_convert_SOURCES = +EXTRA_jv_convert_SOURCES = $(convert_source_files) +jv_convert_LDFLAGS = --main=gnu.gcj.convert.Convert +jv_convert_LINK = $(GCJ) $(JC1FLAGS) $(LDFLAGS) -o jv-convert +jv_convert_LDADD = $(convert_source_files:.java=.o) -L. $(GCLIBS) $(THREADLIBS) +jv_convert_DEPENDENCIES = $(convert_source_files:.java=.o) \ + $(GCDEPS) $(THREADDEPS) libgcj.a + +# The Unicode consortium does not permit re-distributing the file JIS0208.TXT. +# You can get it from ftp://ftp.unicode.org/Public/MAPPINGS/EASTASIA/JIS/. + +$(srcdir)/$(CONVERT_DIR)/JIS0208.h: # JIS0208.TXT + echo '/* This file is autoamtically generated from Unicode tables */' > tmp-0208; \ + sed -n -e 's|\(0x....\).*0x\(..\)\(..\).*\(0x....\).*#\(.*\).$$|MAP(0x\2, 0x\3, \4) /*\5 */|p' \ + > tmp-0208; \ + mv tmp-0208 $(srcdir)/$(CONVERT_DIR)/JIS0208.h + +# The Unicode consortium does not permit re-distributing the file JIS0212.TXT. +# You can get it from ftp://ftp.unicode.org/Public/MAPPINGS/EASTASIA/JIS/. + +$(srcdir)/$(CONVERT_DIR)/JIS0212.h: # JIS0212.TXT + echo '/* This file is autoamtically generated from Unicode tables */' > tmp-0212; \ + sed -n -e 's|0x\(..\)\(..\).*\(0x....\).*#\(.*\).$$|MAP(0x\1, 0x\2, \3) /*\4 */|p' \ + > tmp-0212; \ + mv tmp-0212 $(srcdir)/$(CONVERT_DIR)/JIS0212.h + + +gen_from_JIS_SOURCES = +EXTRA_gen_from_JIS_SOURCES = $(srcdir)/$(CONVERT_DIR)/gen-from-JIS.c \ + $(srcdir)/$(CONVERT_DIR)/JIS0208.h \ + $(srcdir)/$(CONVERT_DIR)/JIS0212.h +gen_from_JIS_LDADD = $(CONVERT_DIR)/gen-from-JIS.o +gen_from_JIS_DEPENDENCIES = $(CONVERT_DIR)/gen-from-JIS.o + +$(CONVERT_DIR)/gen-from-JIS.o: $(srcdir)/$(CONVERT_DIR)/gen-from-JIS.c \ + $(srcdir)/$(CONVERT_DIR)/JIS0208.h \ + $(srcdir)/$(CONVERT_DIR)/JIS0212.h + $(COMPILE) -c -o $(CONVERT_DIR)/gen-from-JIS.o \ + $(srcdir)/$(CONVERT_DIR)/gen-from-JIS.c + +if NATIVE +if MAINTAINER_MODE + +$(srcdir)/$(CONVERT_DIR)/JIS0208_to_Unicode.cc: ./gen-from-JIS$(EXEEXT) + ./gen-from-JIS JIS0208>$(srcdir)/$(CONVERT_DIR)/JIS0208_to_Unicode.cc + +$(srcdir)/$(CONVERT_DIR)/JIS0212_to_Unicode.cc: ./gen-from-JIS$(EXEEXT) + ./gen-from-JIS JIS0212>$(srcdir)/$(CONVERT_DIR)/JIS0212_to_Unicode.cc + +endif # MAINTAINER_MODE +endif # NATIVE + + +## ################################################################ + +## +## This section lists all the source files we care about. +## + +convert_source_files = \ +gnu/gcj/convert/BytesToUnicode.java \ +gnu/gcj/convert/Convert.java \ +gnu/gcj/convert/Input_8859_1.java \ +gnu/gcj/convert/Input_EUCJIS.java \ +gnu/gcj/convert/Input_UTF8.java \ +gnu/gcj/convert/Output_8859_1.java \ +gnu/gcj/convert/Output_JavaSrc.java \ +gnu/gcj/convert/Output_UTF8.java \ +gnu/gcj/convert/UnicodeToBytes.java + +## List of all .java files for which the .h file is maintained by +## hand. +special_java_source_files = java/lang/Class.java java/lang/Object.java + +## List of all .java files to be compiled. Please keep this list +## alphabetical. Please put files from gnu/gcj/convert into +## convert_source_files. If the .java file has a hand-maintained +## header, please list it in special_java_source_files. +ordinary_java_source_files = $(convert_source_files) \ +gnu/gcj/text/BaseBreakIterator.java \ +gnu/gcj/text/CharacterBreakIterator.java \ +gnu/gcj/text/LineBreakIterator.java \ +gnu/gcj/text/LocaleData_en.java \ +gnu/gcj/text/LocaleData_en_US.java \ +gnu/gcj/text/SentenceBreakIterator.java \ +gnu/gcj/text/WordBreakIterator.java \ +gnu/gcj/protocol/http/Connection.java \ +gnu/gcj/protocol/http/Handler.java \ +java/io/BufferedInputStream.java \ +java/io/BufferedOutputStream.java \ +java/io/BufferedReader.java \ +java/io/BufferedWriter.java \ +java/io/ByteArrayInputStream.java \ +java/io/ByteArrayOutputStream.java \ +java/io/CharArrayReader.java \ +java/io/CharArrayWriter.java \ +java/io/CharConversionException.java \ +java/io/DataInput.java \ +java/io/DataInputStream.java \ +java/io/DataOutput.java \ +java/io/DataOutputStream.java \ +java/io/EOFException.java \ +java/io/File.java \ +java/io/FileDescriptor.java \ +java/io/FileInputStream.java \ +java/io/FileNotFoundException.java \ +java/io/FileOutputStream.java \ +java/io/FileReader.java \ +java/io/FileWriter.java \ +java/io/FilenameFilter.java \ +java/io/FilterInputStream.java \ +java/io/FilterOutputStream.java \ +java/io/FilterReader.java \ +java/io/FilterWriter.java \ +java/io/IOException.java \ +java/io/InputStream.java \ +java/io/InputStreamReader.java \ +java/io/InterruptedIOException.java \ +java/io/LineNumberInputStream.java \ +java/io/LineNumberReader.java \ +java/io/OutputStream.java \ +java/io/OutputStreamWriter.java \ +java/io/PipedInputStream.java \ +java/io/PipedOutputStream.java \ +java/io/PipedReader.java \ +java/io/PipedWriter.java \ +java/io/PrintStream.java \ +java/io/PrintWriter.java \ +java/io/PushbackInputStream.java \ +java/io/PushbackReader.java \ +java/io/RandomAccessFile.java \ +java/io/Reader.java \ +java/io/SequenceInputStream.java \ +java/io/Serializable.java \ +java/io/StreamTokenizer.java \ +java/io/StringBufferInputStream.java \ +java/io/StringReader.java \ +java/io/StringWriter.java \ +java/io/SyncFailedException.java \ +java/io/UTFDataFormatException.java \ +java/io/UnsupportedEncodingException.java \ +java/io/Writer.java \ +java/lang/AbstractMethodError.java \ +java/lang/ArithmeticException.java \ +java/lang/ArrayIndexOutOfBoundsException.java \ +java/lang/ArrayStoreException.java \ +java/lang/Boolean.java \ +java/lang/Byte.java \ +java/lang/Character.java \ +java/lang/ClassCastException.java \ +java/lang/ClassCircularityError.java \ +java/lang/ClassFormatError.java \ +java/lang/ClassLoader.java \ +java/lang/ClassNotFoundException.java \ +java/lang/CloneNotSupportedException.java \ +java/lang/Cloneable.java \ +java/lang/Comparable.java \ +java/lang/Compiler.java \ +java/lang/Double.java \ +java/lang/Error.java \ +java/lang/Exception.java \ +java/lang/ExceptionInInitializerError.java \ +java/lang/FirstThread.java \ +java/lang/Float.java \ +java/lang/IllegalAccessError.java \ +java/lang/IllegalAccessException.java \ +java/lang/IllegalArgumentException.java \ +java/lang/IllegalMonitorStateException.java \ +java/lang/IllegalStateException.java \ +java/lang/IllegalThreadStateException.java \ +java/lang/IncompatibleClassChangeError.java \ +java/lang/IndexOutOfBoundsException.java \ +java/lang/InstantiationError.java \ +java/lang/InstantiationException.java \ +java/lang/Integer.java \ +java/lang/InternalError.java \ +java/lang/InterruptedException.java \ +java/lang/LinkageError.java \ +java/lang/Long.java \ +java/lang/Math.java \ +java/lang/NegativeArraySizeException.java \ +java/lang/NoClassDefFoundError.java \ +java/lang/NoSuchFieldError.java \ +java/lang/NoSuchFieldException.java \ +java/lang/NoSuchMethodError.java \ +java/lang/NoSuchMethodException.java \ +java/lang/NullPointerException.java \ +java/lang/Number.java \ +java/lang/NumberFormatException.java \ +java/lang/OutOfMemoryError.java \ +java/lang/Process.java \ +java/lang/Runnable.java \ +java/lang/Runtime.java \ +java/lang/RuntimeException.java \ +java/lang/SecurityException.java \ +java/lang/SecurityManager.java \ +java/lang/Short.java \ +java/lang/StackOverflowError.java \ +java/lang/String.java \ +java/lang/StringBuffer.java \ +java/lang/StringIndexOutOfBoundsException.java \ +java/lang/System.java \ +java/lang/Thread.java \ +java/lang/ThreadDeath.java \ +java/lang/ThreadGroup.java \ +java/lang/Throwable.java \ +java/lang/UnknownError.java \ +java/lang/UnsatisfiedLinkError.java \ +java/lang/UnsupportedOperationException.java \ +java/lang/VerifyError.java \ +java/lang/VirtualMachineError.java \ +java/lang/Void.java \ +java/lang/reflect/AccessibleObject.java \ +java/lang/reflect/Array.java \ +java/lang/reflect/Constructor.java \ +java/lang/reflect/Field.java \ +java/lang/reflect/InvocationTargetException.java \ +java/lang/reflect/Member.java \ +java/lang/reflect/Method.java \ +java/lang/reflect/Modifier.java \ +java/net/BindException.java \ +java/net/ConnectException.java \ +java/net/ContentHandler.java \ +java/net/ContentHandlerFactory.java \ +java/net/FileNameMap.java \ +java/net/HttpURLConnection.java \ +java/net/InetAddress.java \ +java/net/MalformedURLException.java \ +java/net/NoRouteToHostException.java \ +java/net/PlainSocketImpl.java \ +java/net/ProtocolException.java \ +java/net/ServerSocket.java \ +java/net/Socket.java \ +java/net/SocketException.java \ +java/net/SocketImpl.java \ +java/net/SocketImplFactory.java \ +java/net/URL.java \ +java/net/URLConnection.java \ +java/net/URLStreamHandler.java \ +java/net/URLStreamHandlerFactory.java \ +java/net/UnknownHostException.java \ +java/net/UnknownServiceException.java \ +java/text/BreakIterator.java \ +java/text/CharacterIterator.java \ +java/text/ChoiceFormat.java \ +java/text/DateFormat.java \ +java/text/DateFormatSymbols.java \ +java/text/DecimalFormat.java \ +java/text/DecimalFormatSymbols.java \ +java/text/FieldPosition.java \ +java/text/Format.java \ +java/text/MessageFormat.java \ +java/text/NumberFormat.java \ +java/text/ParseException.java \ +java/text/ParsePosition.java \ +java/text/SimpleDateFormat.java \ +java/text/StringCharacterIterator.java \ +java/util/BitSet.java \ +java/util/Calendar.java \ +java/util/ConcurrentModificationException.java \ +java/util/Date.java \ +java/util/Dictionary.java \ +java/util/EmptyStackException.java \ +java/util/Enumeration.java \ +java/util/EventListener.java \ +java/util/EventObject.java \ +java/util/GregorianCalendar.java \ +java/util/Hashtable.java \ +java/util/ListResourceBundle.java \ +java/util/Locale.java \ +java/util/MissingResourceException.java \ +java/util/NoSuchElementException.java \ +java/util/Observable.java \ +java/util/Observer.java \ +java/util/Properties.java \ +java/util/Random.java \ +java/util/ResourceBundle.java \ +java/util/SimpleTimeZone.java \ +java/util/Stack.java \ +java/util/StringTokenizer.java \ +java/util/TimeZone.java \ +java/util/TooManyListenersException.java \ +java/util/Vector.java \ +java/util/zip/Adler32.java \ +java/util/zip/CRC32.java \ +java/util/zip/Checksum.java \ +java/util/zip/Deflater.java \ +java/util/zip/DeflaterOutputStream.java \ +java/util/zip/ZipConstants.java \ +java/util/zip/ZipEntry.java \ +java/util/zip/ZipException.java \ +java/util/zip/ZipFile.java \ +java/util/zip/ZipOutputStream.java + +java_source_files = $(ordinary_java_source_files) $(special_java_source_files) + +## Math library: C, not C++ +c_source_files = \ + java/lang/dtoa.c java/lang/k_rem_pio2.c java/lang/s_tan.c \ + java/lang/e_acos.c java/lang/k_sin.c java/lang/strtod.c \ + java/lang/e_asin.c java/lang/k_tan.c java/lang/w_acos.c \ + java/lang/e_atan2.c java/lang/mprec.c java/lang/w_asin.c \ + java/lang/e_exp.c java/lang/s_atan.c java/lang/w_atan2.c \ + java/lang/e_fmod.c java/lang/s_ceil.c java/lang/w_exp.c \ + java/lang/e_log.c java/lang/s_copysign.c java/lang/w_fmod.c \ + java/lang/e_pow.c java/lang/s_cos.c java/lang/w_log.c \ + java/lang/e_rem_pio2.c java/lang/s_fabs.c java/lang/w_pow.c \ + java/lang/e_remainder.c java/lang/s_floor.c java/lang/w_remainder.c \ + java/lang/e_scalb.c java/lang/s_rint.c java/lang/w_sqrt.c \ + java/lang/e_sqrt.c java/lang/s_scalbn.c java/lang/sf_rint.c \ + java/lang/k_cos.c java/lang/s_sin.c + +## This lists all the C++ source files in subdirectories. +nat_source_files = java/lang/natObject.cc java/lang/natClass.cc \ +java/lang/natString.cc java/lang/natDouble.cc java/lang/natRuntime.cc \ +java/lang/natSystem.cc java/lang/natThread.cc java/io/natFile.cc \ +java/io/natFileDescriptor.cc java/util/natDate.cc \ +java/util/natGregorianCalendar.cc java/lang/natFirstThread.cc \ +java/lang/natCharacter.cc java/lang/natMath.cc java/lang/natFloat.cc \ +java/lang/reflect/natField.cc java/net/natInetAddress.cc \ +java/net/natPlainSocketImpl.cc java/lang/reflect/natMethod.cc \ +java/lang/reflect/natArray.cc gnu/gcj/convert/natInput_EUCJIS.cc \ +gnu/gcj/convert/JIS0208_to_Unicode.cc \ +gnu/gcj/convert/JIS0212_to_Unicode.cc + +## ################################################################ + +## +## This section is for make and multilib madness. +## + +# Work around what appears to be a GNU make bug handling MAKEFLAGS +# values defined in terms of make variables, as is the case for CC and +# friends when we are called from the top level Makefile. +AM_MAKEFLAGS = \ + "AR_FLAGS=$(AR_FLAGS)" \ + "CC_FOR_BUILD=$(CC_FOR_BUILD)" \ + "CFLAGS=$(CFLAGS)" \ + "CXXFLAGS=$(CXXFLAGS)" \ + "CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \ + "CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \ + "INSTALL=$(INSTALL)" \ + "INSTALL_DATA=$(INSTALL_DATA)" \ + "INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \ + "INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \ + "LDFLAGS=$(LDFLAGS)" \ + "LIBCFLAGS=$(LIBCFLAGS)" \ + "LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \ + "MAKE=$(MAKE)" \ + "MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \ + "PICFLAG=$(PICFLAG)" \ + "PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" \ + "SHELL=$(SHELL)" \ + "exec_prefix=$(exec_prefix)" \ + "infodir=$(infodir)" \ + "libdir=$(libdir)" \ + "prefix=$(prefix)" \ + "AR=$(AR)" \ + "AS=$(AS)" \ + "CC=$(CC)" \ + "CXX=$(CXX)" \ + "LD=$(LD)" \ + "LIBCFLAGS=$(LIBCFLAGS)" \ + "NM=$(NM)" \ + "PICFLAG=$(PICFLAG)" \ + "RANLIB=$(RANLIB)" \ + "DESTDIR=$(DESTDIR)" + +CONFIG_STATUS_DEPENDENCIES = $(libgcj_basedir)/configure.host + +MAKEOVERRIDES= + +# Multilib support variables. +MULTISRCTOP = +MULTIBUILDTOP = +MULTIDIRS = +MULTISUBDIR = +MULTIDO = true +MULTICLEAN = true + +# Multilib support. +.PHONY: all-multi mostlyclean-multi clean-multi distclean-multi \ + maintainer-clean-multi + +all-recursive: all-multi +install-recursive: install-multi +mostlyclean-recursive: mostlyclean-multi +clean-recursive: clean-multi +distclean-recursive: distclean-multi +maintainer-clean-recursive: maintainer-clean-multi + +all-multi: + $(MULTIDO) $(AM_MAKEFLAGS) DO=all multi-do +install-multi: + $(MULTIDO) $(AM_MAKEFLAGS) DO=install multi-do +mostlyclean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=mostlyclean multi-clean +clean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=clean multi-clean +distclean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=distclean multi-clean +maintainer-clean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=maintainer-clean multi-clean + + +## ################################################################ + + +## See above. +cygnus_hack = + + diff --git a/libjava/Makefile.in b/libjava/Makefile.in new file mode 100644 index 00000000000..d47a7f8057a --- /dev/null +++ b/libjava/Makefile.in @@ -0,0 +1,1309 @@ +# Makefile.in generated automatically by automake 1.4 from Makefile.am + +# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + + +SHELL = @SHELL@ + +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ +prefix = @prefix@ +exec_prefix = @exec_prefix@ + +bindir = @bindir@ +sbindir = @sbindir@ +libexecdir = @libexecdir@ +datadir = @datadir@ +sysconfdir = @sysconfdir@ +sharedstatedir = @sharedstatedir@ +localstatedir = @localstatedir@ +libdir = @libdir@ +infodir = @infodir@ +mandir = @mandir@ +includedir = @includedir@ +oldincludedir = /usr/include + +DESTDIR = + +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ + +top_builddir = . + +ACLOCAL = @ACLOCAL@ +AUTOCONF = @AUTOCONF@ +AUTOMAKE = @AUTOMAKE@ +AUTOHEADER = @AUTOHEADER@ + +INSTALL = @INSTALL@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS) +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +transform = @program_transform_name@ + +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_alias = @build_alias@ +build_triplet = @build@ +host_alias = @host_alias@ +host_triplet = @host@ +target_alias = @target_alias@ +target_triplet = @target@ +AM_RUNTESTFLAGS = @AM_RUNTESTFLAGS@ +AR = @AR@ +AS = @AS@ +CC = @CC@ +COMPPATH = @COMPPATH@ +CPP = @CPP@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +EXEEXT = @EXEEXT@ +GCDEPS = @GCDEPS@ +GCINCS = @GCINCS@ +GCLIBS = @GCLIBS@ +GCOBJS = @GCOBJS@ +LIBGCJ_CFLAGS = @LIBGCJ_CFLAGS@ +LIBGCJ_CXXFLAGS = @LIBGCJ_CXXFLAGS@ +LIBGCJ_JAVAFLAGS = @LIBGCJ_JAVAFLAGS@ +MAINT = @MAINT@ +MAKEINFO = @MAKEINFO@ +PACKAGE = @PACKAGE@ +PERL = @PERL@ +RANLIB = @RANLIB@ +THREADDEPS = @THREADDEPS@ +THREADINCS = @THREADINCS@ +THREADLIBS = @THREADLIBS@ +THREADOBJS = @THREADOBJS@ +VERSION = @VERSION@ +here = @here@ +libgcj_basedir = @libgcj_basedir@ + +AUTOMAKE_OPTIONS = foreign no-installinfo + +@TESTSUBDIR_TRUE@SUBDIRS = \ +@TESTSUBDIR_TRUE@testsuite + +toolexecdir = $(exec_prefix)/$(target_alias) +toolexeclibdir = $(toolexecdir)/lib$(MULTISUBDIR) + +toolexeclib_LIBRARIES = libgcj.a +data_DATA = libgcj.zip + +@NATIVE_TRUE@bin_PROGRAMS = \ +@NATIVE_TRUE@jv-convert +@CANADIAN_TRUE@@NULL_TARGET_TRUE@GCJ = \ +@CANADIAN_TRUE@@NULL_TARGET_TRUE@gcj +@CANADIAN_TRUE@@NULL_TARGET_FALSE@GCJ = \ +@CANADIAN_TRUE@@NULL_TARGET_FALSE@$(target_alias)-gcj +@CANADIAN_FALSE@GCJ = \ +@CANADIAN_FALSE@$(expanded)/gcj$(EXEEXT) -B$(expanded)/ +@CANADIAN_TRUE@@NULL_TARGET_TRUE@ZIP = \ +@CANADIAN_TRUE@@NULL_TARGET_TRUE@$(MULTIBUILDTOP)../$(COMPPATH)/zip/zip$(EXEEXT) +@CANADIAN_TRUE@@NULL_TARGET_FALSE@ZIP = \ +@CANADIAN_TRUE@@NULL_TARGET_FALSE@zip +@CANADIAN_FALSE@ZIP = \ +@CANADIAN_FALSE@$(MULTIBUILDTOP)../$(COMPPATH)/zip/zip$(EXEEXT) +@CANADIAN_TRUE@GCJH = \ +@CANADIAN_TRUE@gcjh +@CANADIAN_FALSE@GCJH = \ +@CANADIAN_FALSE@$(MULTIBUILDTOP)../$(COMPPATH)/gcc/gcjh$(EXEEXT) +@CANADIAN_FALSE@expanded = \ +@CANADIAN_FALSE@`cd $(MULTIBUILDTOP)../$(COMPPATH)/gcc && pwd` + +JAVAC = $(GCJ) -C + +EH_COMMON_INCLUDE = @EH_COMMON_INCLUDE@ + +WARNINGS = -W -Wall +AM_CXXFLAGS = -fno-rtti -fvtable-thunks @LIBGCJ_CXXFLAGS@ $(WARNINGS) +@USING_GCC_TRUE@AM_CFLAGS = \ +@USING_GCC_TRUE@@LIBGCJ_CFLAGS@ $(WARNINGS) +@USING_GCC_FALSE@AM_CFLAGS = \ +@USING_GCC_FALSE@@LIBGCJ_CFLAGS@ + +JCFLAGS = -g +JC1FLAGS = -g @LIBGCJ_JAVAFLAGS@ + +INCLUDES = -Iinclude -I$(top_srcdir)/include $(GCINCS) $(THREADINCS) $(EH_COMMON_INCLUDE) + +nat_files = $(nat_source_files:.cc=.o) +c_files = $(c_source_files:.c=.o) +javao_files = $(java_source_files:.java=.o) + +libgcj_a_SOURCES = prims.cc jni.cc exception.cc +EXTRA_libgcj_a_SOURCES = boehm.cc nogc.cc posix-threads.cc no-threads.cc \ + $(c_source_files) $(java_source_files) + +libgcj_a_DEPENDENCIES = libgcj.zip $(javao_files) $(nat_files) \ + $(c_files) $(GCOBJS) $(THREADOBJS) + +libgcj_a_LIBADD = $(javao_files) $(nat_files) $(c_files) $(GCOBJS) \ + $(THREADOBJS) + + +MOSTLYCLEANFILES = $(javao_files) $(nat_files) $(nat_headers) $(c_files) +CLEANFILES = libgcj.zip $(class_files) + +SUFFIXES = .class .java .h + +nat_headers = $(ordinary_java_source_files:.java=.h) + +FTFRIEND = void JvRunMain (jclass klass, int argc, const char **argv) + +TGFRIEND = void JvRunMain (jclass klass, int argc, const char **argv) + +NM = nm + +@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@noinst_PROGRAMS = \ +@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@gen-from-JIS + +CONVERT_DIR = gnu/gcj/convert + +jv_convert_SOURCES = +EXTRA_jv_convert_SOURCES = $(convert_source_files) +jv_convert_LDFLAGS = --main=gnu.gcj.convert.Convert +jv_convert_LINK = $(GCJ) $(JC1FLAGS) $(LDFLAGS) -o jv-convert +jv_convert_LDADD = $(convert_source_files:.java=.o) -L. $(GCLIBS) $(THREADLIBS) +jv_convert_DEPENDENCIES = $(convert_source_files:.java=.o) \ + $(GCDEPS) $(THREADDEPS) libgcj.a + + +gen_from_JIS_SOURCES = +EXTRA_gen_from_JIS_SOURCES = $(srcdir)/$(CONVERT_DIR)/gen-from-JIS.c \ + $(srcdir)/$(CONVERT_DIR)/JIS0208.h \ + $(srcdir)/$(CONVERT_DIR)/JIS0212.h + +gen_from_JIS_LDADD = $(CONVERT_DIR)/gen-from-JIS.o +gen_from_JIS_DEPENDENCIES = $(CONVERT_DIR)/gen-from-JIS.o + +convert_source_files = \ +gnu/gcj/convert/BytesToUnicode.java \ +gnu/gcj/convert/Convert.java \ +gnu/gcj/convert/Input_8859_1.java \ +gnu/gcj/convert/Input_EUCJIS.java \ +gnu/gcj/convert/Input_UTF8.java \ +gnu/gcj/convert/Output_8859_1.java \ +gnu/gcj/convert/Output_JavaSrc.java \ +gnu/gcj/convert/Output_UTF8.java \ +gnu/gcj/convert/UnicodeToBytes.java + + +special_java_source_files = java/lang/Class.java java/lang/Object.java + +ordinary_java_source_files = $(convert_source_files) \ +gnu/gcj/text/BaseBreakIterator.java \ +gnu/gcj/text/CharacterBreakIterator.java \ +gnu/gcj/text/LineBreakIterator.java \ +gnu/gcj/text/LocaleData_en.java \ +gnu/gcj/text/LocaleData_en_US.java \ +gnu/gcj/text/SentenceBreakIterator.java \ +gnu/gcj/text/WordBreakIterator.java \ +gnu/gcj/protocol/http/Connection.java \ +gnu/gcj/protocol/http/Handler.java \ +java/io/BufferedInputStream.java \ +java/io/BufferedOutputStream.java \ +java/io/BufferedReader.java \ +java/io/BufferedWriter.java \ +java/io/ByteArrayInputStream.java \ +java/io/ByteArrayOutputStream.java \ +java/io/CharArrayReader.java \ +java/io/CharArrayWriter.java \ +java/io/CharConversionException.java \ +java/io/DataInput.java \ +java/io/DataInputStream.java \ +java/io/DataOutput.java \ +java/io/DataOutputStream.java \ +java/io/EOFException.java \ +java/io/File.java \ +java/io/FileDescriptor.java \ +java/io/FileInputStream.java \ +java/io/FileNotFoundException.java \ +java/io/FileOutputStream.java \ +java/io/FileReader.java \ +java/io/FileWriter.java \ +java/io/FilenameFilter.java \ +java/io/FilterInputStream.java \ +java/io/FilterOutputStream.java \ +java/io/FilterReader.java \ +java/io/FilterWriter.java \ +java/io/IOException.java \ +java/io/InputStream.java \ +java/io/InputStreamReader.java \ +java/io/InterruptedIOException.java \ +java/io/LineNumberInputStream.java \ +java/io/LineNumberReader.java \ +java/io/OutputStream.java \ +java/io/OutputStreamWriter.java \ +java/io/PipedInputStream.java \ +java/io/PipedOutputStream.java \ +java/io/PipedReader.java \ +java/io/PipedWriter.java \ +java/io/PrintStream.java \ +java/io/PrintWriter.java \ +java/io/PushbackInputStream.java \ +java/io/PushbackReader.java \ +java/io/RandomAccessFile.java \ +java/io/Reader.java \ +java/io/SequenceInputStream.java \ +java/io/Serializable.java \ +java/io/StreamTokenizer.java \ +java/io/StringBufferInputStream.java \ +java/io/StringReader.java \ +java/io/StringWriter.java \ +java/io/SyncFailedException.java \ +java/io/UTFDataFormatException.java \ +java/io/UnsupportedEncodingException.java \ +java/io/Writer.java \ +java/lang/AbstractMethodError.java \ +java/lang/ArithmeticException.java \ +java/lang/ArrayIndexOutOfBoundsException.java \ +java/lang/ArrayStoreException.java \ +java/lang/Boolean.java \ +java/lang/Byte.java \ +java/lang/Character.java \ +java/lang/ClassCastException.java \ +java/lang/ClassCircularityError.java \ +java/lang/ClassFormatError.java \ +java/lang/ClassLoader.java \ +java/lang/ClassNotFoundException.java \ +java/lang/CloneNotSupportedException.java \ +java/lang/Cloneable.java \ +java/lang/Comparable.java \ +java/lang/Compiler.java \ +java/lang/Double.java \ +java/lang/Error.java \ +java/lang/Exception.java \ +java/lang/ExceptionInInitializerError.java \ +java/lang/FirstThread.java \ +java/lang/Float.java \ +java/lang/IllegalAccessError.java \ +java/lang/IllegalAccessException.java \ +java/lang/IllegalArgumentException.java \ +java/lang/IllegalMonitorStateException.java \ +java/lang/IllegalStateException.java \ +java/lang/IllegalThreadStateException.java \ +java/lang/IncompatibleClassChangeError.java \ +java/lang/IndexOutOfBoundsException.java \ +java/lang/InstantiationError.java \ +java/lang/InstantiationException.java \ +java/lang/Integer.java \ +java/lang/InternalError.java \ +java/lang/InterruptedException.java \ +java/lang/LinkageError.java \ +java/lang/Long.java \ +java/lang/Math.java \ +java/lang/NegativeArraySizeException.java \ +java/lang/NoClassDefFoundError.java \ +java/lang/NoSuchFieldError.java \ +java/lang/NoSuchFieldException.java \ +java/lang/NoSuchMethodError.java \ +java/lang/NoSuchMethodException.java \ +java/lang/NullPointerException.java \ +java/lang/Number.java \ +java/lang/NumberFormatException.java \ +java/lang/OutOfMemoryError.java \ +java/lang/Process.java \ +java/lang/Runnable.java \ +java/lang/Runtime.java \ +java/lang/RuntimeException.java \ +java/lang/SecurityException.java \ +java/lang/SecurityManager.java \ +java/lang/Short.java \ +java/lang/StackOverflowError.java \ +java/lang/String.java \ +java/lang/StringBuffer.java \ +java/lang/StringIndexOutOfBoundsException.java \ +java/lang/System.java \ +java/lang/Thread.java \ +java/lang/ThreadDeath.java \ +java/lang/ThreadGroup.java \ +java/lang/Throwable.java \ +java/lang/UnknownError.java \ +java/lang/UnsatisfiedLinkError.java \ +java/lang/UnsupportedOperationException.java \ +java/lang/VerifyError.java \ +java/lang/VirtualMachineError.java \ +java/lang/Void.java \ +java/lang/reflect/AccessibleObject.java \ +java/lang/reflect/Array.java \ +java/lang/reflect/Constructor.java \ +java/lang/reflect/Field.java \ +java/lang/reflect/InvocationTargetException.java \ +java/lang/reflect/Member.java \ +java/lang/reflect/Method.java \ +java/lang/reflect/Modifier.java \ +java/net/BindException.java \ +java/net/ConnectException.java \ +java/net/ContentHandler.java \ +java/net/ContentHandlerFactory.java \ +java/net/FileNameMap.java \ +java/net/HttpURLConnection.java \ +java/net/InetAddress.java \ +java/net/MalformedURLException.java \ +java/net/NoRouteToHostException.java \ +java/net/PlainSocketImpl.java \ +java/net/ProtocolException.java \ +java/net/ServerSocket.java \ +java/net/Socket.java \ +java/net/SocketException.java \ +java/net/SocketImpl.java \ +java/net/SocketImplFactory.java \ +java/net/URL.java \ +java/net/URLConnection.java \ +java/net/URLStreamHandler.java \ +java/net/URLStreamHandlerFactory.java \ +java/net/UnknownHostException.java \ +java/net/UnknownServiceException.java \ +java/text/BreakIterator.java \ +java/text/CharacterIterator.java \ +java/text/ChoiceFormat.java \ +java/text/DateFormat.java \ +java/text/DateFormatSymbols.java \ +java/text/DecimalFormat.java \ +java/text/DecimalFormatSymbols.java \ +java/text/FieldPosition.java \ +java/text/Format.java \ +java/text/MessageFormat.java \ +java/text/NumberFormat.java \ +java/text/ParseException.java \ +java/text/ParsePosition.java \ +java/text/SimpleDateFormat.java \ +java/text/StringCharacterIterator.java \ +java/util/BitSet.java \ +java/util/Calendar.java \ +java/util/ConcurrentModificationException.java \ +java/util/Date.java \ +java/util/Dictionary.java \ +java/util/EmptyStackException.java \ +java/util/Enumeration.java \ +java/util/EventListener.java \ +java/util/EventObject.java \ +java/util/GregorianCalendar.java \ +java/util/Hashtable.java \ +java/util/ListResourceBundle.java \ +java/util/Locale.java \ +java/util/MissingResourceException.java \ +java/util/NoSuchElementException.java \ +java/util/Observable.java \ +java/util/Observer.java \ +java/util/Properties.java \ +java/util/Random.java \ +java/util/ResourceBundle.java \ +java/util/SimpleTimeZone.java \ +java/util/Stack.java \ +java/util/StringTokenizer.java \ +java/util/TimeZone.java \ +java/util/TooManyListenersException.java \ +java/util/Vector.java \ +java/util/zip/Adler32.java \ +java/util/zip/CRC32.java \ +java/util/zip/Checksum.java \ +java/util/zip/Deflater.java \ +java/util/zip/DeflaterOutputStream.java \ +java/util/zip/ZipConstants.java \ +java/util/zip/ZipEntry.java \ +java/util/zip/ZipException.java \ +java/util/zip/ZipFile.java \ +java/util/zip/ZipOutputStream.java + + +java_source_files = $(ordinary_java_source_files) $(special_java_source_files) + +c_source_files = \ + java/lang/dtoa.c java/lang/k_rem_pio2.c java/lang/s_tan.c \ + java/lang/e_acos.c java/lang/k_sin.c java/lang/strtod.c \ + java/lang/e_asin.c java/lang/k_tan.c java/lang/w_acos.c \ + java/lang/e_atan2.c java/lang/mprec.c java/lang/w_asin.c \ + java/lang/e_exp.c java/lang/s_atan.c java/lang/w_atan2.c \ + java/lang/e_fmod.c java/lang/s_ceil.c java/lang/w_exp.c \ + java/lang/e_log.c java/lang/s_copysign.c java/lang/w_fmod.c \ + java/lang/e_pow.c java/lang/s_cos.c java/lang/w_log.c \ + java/lang/e_rem_pio2.c java/lang/s_fabs.c java/lang/w_pow.c \ + java/lang/e_remainder.c java/lang/s_floor.c java/lang/w_remainder.c \ + java/lang/e_scalb.c java/lang/s_rint.c java/lang/w_sqrt.c \ + java/lang/e_sqrt.c java/lang/s_scalbn.c java/lang/sf_rint.c \ + java/lang/k_cos.c java/lang/s_sin.c + + +nat_source_files = java/lang/natObject.cc java/lang/natClass.cc \ +java/lang/natString.cc java/lang/natDouble.cc java/lang/natRuntime.cc \ +java/lang/natSystem.cc java/lang/natThread.cc java/io/natFile.cc \ +java/io/natFileDescriptor.cc java/util/natDate.cc \ +java/util/natGregorianCalendar.cc java/lang/natFirstThread.cc \ +java/lang/natCharacter.cc java/lang/natMath.cc java/lang/natFloat.cc \ +java/lang/reflect/natField.cc java/net/natInetAddress.cc \ +java/net/natPlainSocketImpl.cc java/lang/reflect/natMethod.cc \ +java/lang/reflect/natArray.cc gnu/gcj/convert/natInput_EUCJIS.cc \ +gnu/gcj/convert/JIS0208_to_Unicode.cc \ +gnu/gcj/convert/JIS0212_to_Unicode.cc + + +# Work around what appears to be a GNU make bug handling MAKEFLAGS +# values defined in terms of make variables, as is the case for CC and +# friends when we are called from the top level Makefile. +AM_MAKEFLAGS = \ + "AR_FLAGS=$(AR_FLAGS)" \ + "CC_FOR_BUILD=$(CC_FOR_BUILD)" \ + "CFLAGS=$(CFLAGS)" \ + "CXXFLAGS=$(CXXFLAGS)" \ + "CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \ + "CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \ + "INSTALL=$(INSTALL)" \ + "INSTALL_DATA=$(INSTALL_DATA)" \ + "INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \ + "INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \ + "LDFLAGS=$(LDFLAGS)" \ + "LIBCFLAGS=$(LIBCFLAGS)" \ + "LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \ + "MAKE=$(MAKE)" \ + "MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \ + "PICFLAG=$(PICFLAG)" \ + "PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" \ + "SHELL=$(SHELL)" \ + "exec_prefix=$(exec_prefix)" \ + "infodir=$(infodir)" \ + "libdir=$(libdir)" \ + "prefix=$(prefix)" \ + "AR=$(AR)" \ + "AS=$(AS)" \ + "CC=$(CC)" \ + "CXX=$(CXX)" \ + "LD=$(LD)" \ + "LIBCFLAGS=$(LIBCFLAGS)" \ + "NM=$(NM)" \ + "PICFLAG=$(PICFLAG)" \ + "RANLIB=$(RANLIB)" \ + "DESTDIR=$(DESTDIR)" + + +CONFIG_STATUS_DEPENDENCIES = $(libgcj_basedir)/configure.host + +MAKEOVERRIDES = + +# Multilib support variables. +MULTISRCTOP = +MULTIBUILDTOP = +MULTIDIRS = +MULTISUBDIR = +MULTIDO = true +MULTICLEAN = true + + +cygnus_hack = +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs +CONFIG_HEADER = ./include/config.h +CONFIG_CLEAN_FILES = +LIBRARIES = $(toolexeclib_LIBRARIES) + + +DEFS = @DEFS@ -I. -I$(srcdir) -I./include +CPPFLAGS = @CPPFLAGS@ +LDFLAGS = @LDFLAGS@ +LIBS = @LIBS@ +libgcj_a_OBJECTS = prims.o jni.o exception.o +@NATIVE_TRUE@bin_PROGRAMS = jv-convert$(EXEEXT) +@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@noinst_PROGRAMS = \ +@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@gen-from-JIS$(EXEEXT) +PROGRAMS = $(bin_PROGRAMS) $(noinst_PROGRAMS) + +jv_convert_OBJECTS = +gen_from_JIS_OBJECTS = +gen_from_JIS_LDFLAGS = +CXXFLAGS = @CXXFLAGS@ +CXXCOMPILE = $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +CXXLD = $(CXX) +CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(LDFLAGS) -o $@ +CFLAGS = @CFLAGS@ +COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +CCLD = $(CC) +LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ +DATA = $(data_DATA) + +DIST_COMMON = COPYING.LIB ChangeLog Makefile.am Makefile.in acconfig.h \ +acinclude.m4 aclocal.m4 configure configure.in include/config.h.in \ +include/stamp-h.in + + +DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) + +TAR = tar +GZIP_ENV = --best +DIST_SUBDIRS = testsuite +DEP_FILES = .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P .deps/boehm.P \ +.deps/exception.P .deps/gnu/gcj/convert/BytesToUnicode.P \ +.deps/gnu/gcj/convert/Convert.P .deps/gnu/gcj/convert/Input_8859_1.P \ +.deps/gnu/gcj/convert/Input_EUCJIS.P .deps/gnu/gcj/convert/Input_UTF8.P \ +.deps/gnu/gcj/convert/Output_8859_1.P \ +.deps/gnu/gcj/convert/Output_JavaSrc.P \ +.deps/gnu/gcj/convert/Output_UTF8.P \ +.deps/gnu/gcj/convert/UnicodeToBytes.P \ +.deps/gnu/gcj/protocol/http/Connection.P \ +.deps/gnu/gcj/protocol/http/Handler.P \ +.deps/gnu/gcj/text/BaseBreakIterator.P \ +.deps/gnu/gcj/text/CharacterBreakIterator.P \ +.deps/gnu/gcj/text/LineBreakIterator.P \ +.deps/gnu/gcj/text/LocaleData_en.P \ +.deps/gnu/gcj/text/LocaleData_en_US.P \ +.deps/gnu/gcj/text/SentenceBreakIterator.P \ +.deps/gnu/gcj/text/WordBreakIterator.P \ +.deps/java/io/BufferedInputStream.P \ +.deps/java/io/BufferedOutputStream.P .deps/java/io/BufferedReader.P \ +.deps/java/io/BufferedWriter.P .deps/java/io/ByteArrayInputStream.P \ +.deps/java/io/ByteArrayOutputStream.P .deps/java/io/CharArrayReader.P \ +.deps/java/io/CharArrayWriter.P .deps/java/io/CharConversionException.P \ +.deps/java/io/DataInput.P .deps/java/io/DataInputStream.P \ +.deps/java/io/DataOutput.P .deps/java/io/DataOutputStream.P \ +.deps/java/io/EOFException.P .deps/java/io/File.P \ +.deps/java/io/FileDescriptor.P .deps/java/io/FileInputStream.P \ +.deps/java/io/FileNotFoundException.P .deps/java/io/FileOutputStream.P \ +.deps/java/io/FileReader.P .deps/java/io/FileWriter.P \ +.deps/java/io/FilenameFilter.P .deps/java/io/FilterInputStream.P \ +.deps/java/io/FilterOutputStream.P .deps/java/io/FilterReader.P \ +.deps/java/io/FilterWriter.P .deps/java/io/IOException.P \ +.deps/java/io/InputStream.P .deps/java/io/InputStreamReader.P \ +.deps/java/io/InterruptedIOException.P \ +.deps/java/io/LineNumberInputStream.P .deps/java/io/LineNumberReader.P \ +.deps/java/io/OutputStream.P .deps/java/io/OutputStreamWriter.P \ +.deps/java/io/PipedInputStream.P .deps/java/io/PipedOutputStream.P \ +.deps/java/io/PipedReader.P .deps/java/io/PipedWriter.P \ +.deps/java/io/PrintStream.P .deps/java/io/PrintWriter.P \ +.deps/java/io/PushbackInputStream.P .deps/java/io/PushbackReader.P \ +.deps/java/io/RandomAccessFile.P .deps/java/io/Reader.P \ +.deps/java/io/SequenceInputStream.P .deps/java/io/Serializable.P \ +.deps/java/io/StreamTokenizer.P .deps/java/io/StringBufferInputStream.P \ +.deps/java/io/StringReader.P .deps/java/io/StringWriter.P \ +.deps/java/io/SyncFailedException.P \ +.deps/java/io/UTFDataFormatException.P \ +.deps/java/io/UnsupportedEncodingException.P .deps/java/io/Writer.P \ +.deps/java/lang/AbstractMethodError.P \ +.deps/java/lang/ArithmeticException.P \ +.deps/java/lang/ArrayIndexOutOfBoundsException.P \ +.deps/java/lang/ArrayStoreException.P .deps/java/lang/Boolean.P \ +.deps/java/lang/Byte.P .deps/java/lang/Character.P \ +.deps/java/lang/Class.P .deps/java/lang/ClassCastException.P \ +.deps/java/lang/ClassCircularityError.P \ +.deps/java/lang/ClassFormatError.P .deps/java/lang/ClassLoader.P \ +.deps/java/lang/ClassNotFoundException.P \ +.deps/java/lang/CloneNotSupportedException.P \ +.deps/java/lang/Cloneable.P .deps/java/lang/Comparable.P \ +.deps/java/lang/Compiler.P .deps/java/lang/Double.P \ +.deps/java/lang/Error.P .deps/java/lang/Exception.P \ +.deps/java/lang/ExceptionInInitializerError.P \ +.deps/java/lang/FirstThread.P .deps/java/lang/Float.P \ +.deps/java/lang/IllegalAccessError.P \ +.deps/java/lang/IllegalAccessException.P \ +.deps/java/lang/IllegalArgumentException.P \ +.deps/java/lang/IllegalMonitorStateException.P \ +.deps/java/lang/IllegalStateException.P \ +.deps/java/lang/IllegalThreadStateException.P \ +.deps/java/lang/IncompatibleClassChangeError.P \ +.deps/java/lang/IndexOutOfBoundsException.P \ +.deps/java/lang/InstantiationError.P \ +.deps/java/lang/InstantiationException.P .deps/java/lang/Integer.P \ +.deps/java/lang/InternalError.P .deps/java/lang/InterruptedException.P \ +.deps/java/lang/LinkageError.P .deps/java/lang/Long.P \ +.deps/java/lang/Math.P .deps/java/lang/NegativeArraySizeException.P \ +.deps/java/lang/NoClassDefFoundError.P \ +.deps/java/lang/NoSuchFieldError.P \ +.deps/java/lang/NoSuchFieldException.P \ +.deps/java/lang/NoSuchMethodError.P \ +.deps/java/lang/NoSuchMethodException.P \ +.deps/java/lang/NullPointerException.P .deps/java/lang/Number.P \ +.deps/java/lang/NumberFormatException.P .deps/java/lang/Object.P \ +.deps/java/lang/OutOfMemoryError.P .deps/java/lang/Process.P \ +.deps/java/lang/Runnable.P .deps/java/lang/Runtime.P \ +.deps/java/lang/RuntimeException.P .deps/java/lang/SecurityException.P \ +.deps/java/lang/SecurityManager.P .deps/java/lang/Short.P \ +.deps/java/lang/StackOverflowError.P .deps/java/lang/String.P \ +.deps/java/lang/StringBuffer.P \ +.deps/java/lang/StringIndexOutOfBoundsException.P \ +.deps/java/lang/System.P .deps/java/lang/Thread.P \ +.deps/java/lang/ThreadDeath.P .deps/java/lang/ThreadGroup.P \ +.deps/java/lang/Throwable.P .deps/java/lang/UnknownError.P \ +.deps/java/lang/UnsatisfiedLinkError.P \ +.deps/java/lang/UnsupportedOperationException.P \ +.deps/java/lang/VerifyError.P .deps/java/lang/VirtualMachineError.P \ +.deps/java/lang/Void.P .deps/java/lang/dtoa.P .deps/java/lang/e_acos.P \ +.deps/java/lang/e_asin.P .deps/java/lang/e_atan2.P \ +.deps/java/lang/e_exp.P .deps/java/lang/e_fmod.P \ +.deps/java/lang/e_log.P .deps/java/lang/e_pow.P \ +.deps/java/lang/e_rem_pio2.P .deps/java/lang/e_remainder.P \ +.deps/java/lang/e_scalb.P .deps/java/lang/e_sqrt.P \ +.deps/java/lang/k_cos.P .deps/java/lang/k_rem_pio2.P \ +.deps/java/lang/k_sin.P .deps/java/lang/k_tan.P .deps/java/lang/mprec.P \ +.deps/java/lang/reflect/AccessibleObject.P \ +.deps/java/lang/reflect/Array.P .deps/java/lang/reflect/Constructor.P \ +.deps/java/lang/reflect/Field.P \ +.deps/java/lang/reflect/InvocationTargetException.P \ +.deps/java/lang/reflect/Member.P .deps/java/lang/reflect/Method.P \ +.deps/java/lang/reflect/Modifier.P .deps/java/lang/s_atan.P \ +.deps/java/lang/s_ceil.P .deps/java/lang/s_copysign.P \ +.deps/java/lang/s_cos.P .deps/java/lang/s_fabs.P \ +.deps/java/lang/s_floor.P .deps/java/lang/s_rint.P \ +.deps/java/lang/s_scalbn.P .deps/java/lang/s_sin.P \ +.deps/java/lang/s_tan.P .deps/java/lang/sf_rint.P \ +.deps/java/lang/strtod.P .deps/java/lang/w_acos.P \ +.deps/java/lang/w_asin.P .deps/java/lang/w_atan2.P \ +.deps/java/lang/w_exp.P .deps/java/lang/w_fmod.P \ +.deps/java/lang/w_log.P .deps/java/lang/w_pow.P \ +.deps/java/lang/w_remainder.P .deps/java/lang/w_sqrt.P \ +.deps/java/net/BindException.P .deps/java/net/ConnectException.P \ +.deps/java/net/ContentHandler.P .deps/java/net/ContentHandlerFactory.P \ +.deps/java/net/FileNameMap.P .deps/java/net/HttpURLConnection.P \ +.deps/java/net/InetAddress.P .deps/java/net/MalformedURLException.P \ +.deps/java/net/NoRouteToHostException.P \ +.deps/java/net/PlainSocketImpl.P .deps/java/net/ProtocolException.P \ +.deps/java/net/ServerSocket.P .deps/java/net/Socket.P \ +.deps/java/net/SocketException.P .deps/java/net/SocketImpl.P \ +.deps/java/net/SocketImplFactory.P .deps/java/net/URL.P \ +.deps/java/net/URLConnection.P .deps/java/net/URLStreamHandler.P \ +.deps/java/net/URLStreamHandlerFactory.P \ +.deps/java/net/UnknownHostException.P \ +.deps/java/net/UnknownServiceException.P \ +.deps/java/text/BreakIterator.P .deps/java/text/CharacterIterator.P \ +.deps/java/text/ChoiceFormat.P .deps/java/text/DateFormat.P \ +.deps/java/text/DateFormatSymbols.P .deps/java/text/DecimalFormat.P \ +.deps/java/text/DecimalFormatSymbols.P .deps/java/text/FieldPosition.P \ +.deps/java/text/Format.P .deps/java/text/MessageFormat.P \ +.deps/java/text/NumberFormat.P .deps/java/text/ParseException.P \ +.deps/java/text/ParsePosition.P .deps/java/text/SimpleDateFormat.P \ +.deps/java/text/StringCharacterIterator.P .deps/java/util/BitSet.P \ +.deps/java/util/Calendar.P \ +.deps/java/util/ConcurrentModificationException.P \ +.deps/java/util/Date.P .deps/java/util/Dictionary.P \ +.deps/java/util/EmptyStackException.P .deps/java/util/Enumeration.P \ +.deps/java/util/EventListener.P .deps/java/util/EventObject.P \ +.deps/java/util/GregorianCalendar.P .deps/java/util/Hashtable.P \ +.deps/java/util/ListResourceBundle.P .deps/java/util/Locale.P \ +.deps/java/util/MissingResourceException.P \ +.deps/java/util/NoSuchElementException.P .deps/java/util/Observable.P \ +.deps/java/util/Observer.P .deps/java/util/Properties.P \ +.deps/java/util/Random.P .deps/java/util/ResourceBundle.P \ +.deps/java/util/SimpleTimeZone.P .deps/java/util/Stack.P \ +.deps/java/util/StringTokenizer.P .deps/java/util/TimeZone.P \ +.deps/java/util/TooManyListenersException.P .deps/java/util/Vector.P \ +.deps/java/util/zip/Adler32.P .deps/java/util/zip/CRC32.P \ +.deps/java/util/zip/Checksum.P .deps/java/util/zip/Deflater.P \ +.deps/java/util/zip/DeflaterOutputStream.P \ +.deps/java/util/zip/ZipConstants.P .deps/java/util/zip/ZipEntry.P \ +.deps/java/util/zip/ZipException.P .deps/java/util/zip/ZipFile.P \ +.deps/java/util/zip/ZipOutputStream.P .deps/jni.P .deps/no-threads.P \ +.deps/nogc.P .deps/posix-threads.P .deps/prims.P +SOURCES = $(libgcj_a_SOURCES) $(EXTRA_libgcj_a_SOURCES) $(jv_convert_SOURCES) $(EXTRA_jv_convert_SOURCES) $(gen_from_JIS_SOURCES) $(EXTRA_gen_from_JIS_SOURCES) +OBJECTS = $(libgcj_a_OBJECTS) $(jv_convert_OBJECTS) $(gen_from_JIS_OBJECTS) + +all: all-redirect +.SUFFIXES: +.SUFFIXES: .S .c .cc .class .h .java .o .s +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) + cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile + +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES) + cd $(top_builddir) \ + && CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status + +$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ configure.in acinclude.m4 + cd $(srcdir) && $(ACLOCAL) + +config.status: $(srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + $(SHELL) ./config.status --recheck +$(srcdir)/configure: @MAINTAINER_MODE_TRUE@$(srcdir)/configure.in $(ACLOCAL_M4) $(CONFIGURE_DEPENDENCIES) + cd $(srcdir) && $(AUTOCONF) + +include/config.h: include/stamp-h + @if test ! -f $@; then \ + rm -f include/stamp-h; \ + $(MAKE) include/stamp-h; \ + else :; fi +include/stamp-h: $(srcdir)/include/config.h.in $(top_builddir)/config.status + cd $(top_builddir) \ + && CONFIG_FILES= CONFIG_HEADERS=include/config.h \ + $(SHELL) ./config.status + @echo timestamp > include/stamp-h 2> /dev/null +$(srcdir)/include/config.h.in: @MAINTAINER_MODE_TRUE@$(srcdir)/include/stamp-h.in + @if test ! -f $@; then \ + rm -f $(srcdir)/include/stamp-h.in; \ + $(MAKE) $(srcdir)/include/stamp-h.in; \ + else :; fi +$(srcdir)/include/stamp-h.in: $(top_srcdir)/configure.in $(ACLOCAL_M4) acconfig.h + cd $(top_srcdir) && $(AUTOHEADER) + @echo timestamp > $(srcdir)/include/stamp-h.in 2> /dev/null + +mostlyclean-hdr: + +clean-hdr: + +distclean-hdr: + -rm -f include/config.h + +maintainer-clean-hdr: + +mostlyclean-toolexeclibLIBRARIES: + +clean-toolexeclibLIBRARIES: + -test -z "$(toolexeclib_LIBRARIES)" || rm -f $(toolexeclib_LIBRARIES) + +distclean-toolexeclibLIBRARIES: + +maintainer-clean-toolexeclibLIBRARIES: + +install-toolexeclibLIBRARIES: $(toolexeclib_LIBRARIES) + @$(NORMAL_INSTALL) + $(mkinstalldirs) $(DESTDIR)$(toolexeclibdir) + @list='$(toolexeclib_LIBRARIES)'; for p in $$list; do \ + if test -f $$p; then \ + echo " $(INSTALL_DATA) $$p $(DESTDIR)$(toolexeclibdir)/$$p"; \ + $(INSTALL_DATA) $$p $(DESTDIR)$(toolexeclibdir)/$$p; \ + else :; fi; \ + done + @$(POST_INSTALL) + @list='$(toolexeclib_LIBRARIES)'; for p in $$list; do \ + if test -f $$p; then \ + echo " $(RANLIB) $(DESTDIR)$(toolexeclibdir)/$$p"; \ + $(RANLIB) $(DESTDIR)$(toolexeclibdir)/$$p; \ + else :; fi; \ + done + +uninstall-toolexeclibLIBRARIES: + @$(NORMAL_UNINSTALL) + list='$(toolexeclib_LIBRARIES)'; for p in $$list; do \ + rm -f $(DESTDIR)$(toolexeclibdir)/$$p; \ + done + +.s.o: + $(COMPILE) -c $< + +.S.o: + $(COMPILE) -c $< + +mostlyclean-compile: + -rm -f *.o core *.core + +clean-compile: + +distclean-compile: + -rm -f *.tab.c + +maintainer-clean-compile: + +libgcj.a: $(libgcj_a_OBJECTS) $(libgcj_a_DEPENDENCIES) + -rm -f libgcj.a + $(AR) cru libgcj.a $(libgcj_a_OBJECTS) $(libgcj_a_LIBADD) + $(RANLIB) libgcj.a + +mostlyclean-binPROGRAMS: + +clean-binPROGRAMS: + -test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS) + +distclean-binPROGRAMS: + +maintainer-clean-binPROGRAMS: + +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + $(mkinstalldirs) $(DESTDIR)$(bindir) + @list='$(bin_PROGRAMS)'; for p in $$list; do \ + if test -f $$p; then \ + echo " $(INSTALL_PROGRAM) $$p $(DESTDIR)$(bindir)/`echo $$p|sed 's/$(EXEEXT)$$//'|sed '$(transform)'|sed 's/$$/$(EXEEXT)/'`"; \ + $(INSTALL_PROGRAM) $$p $(DESTDIR)$(bindir)/`echo $$p|sed 's/$(EXEEXT)$$//'|sed '$(transform)'|sed 's/$$/$(EXEEXT)/'`; \ + else :; fi; \ + done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + list='$(bin_PROGRAMS)'; for p in $$list; do \ + rm -f $(DESTDIR)$(bindir)/`echo $$p|sed 's/$(EXEEXT)$$//'|sed '$(transform)'|sed 's/$$/$(EXEEXT)/'`; \ + done + +mostlyclean-noinstPROGRAMS: + +clean-noinstPROGRAMS: + -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS) + +distclean-noinstPROGRAMS: + +maintainer-clean-noinstPROGRAMS: + +jv-convert$(EXEEXT): $(jv_convert_OBJECTS) $(jv_convert_DEPENDENCIES) + @rm -f jv-convert$(EXEEXT) + $(jv_convert_LINK) $(jv_convert_LDFLAGS) $(jv_convert_OBJECTS) $(jv_convert_LDADD) $(LIBS) + +gen-from-JIS$(EXEEXT): $(gen_from_JIS_OBJECTS) $(gen_from_JIS_DEPENDENCIES) + @rm -f gen-from-JIS$(EXEEXT) + $(LINK) $(gen_from_JIS_LDFLAGS) $(gen_from_JIS_OBJECTS) $(gen_from_JIS_LDADD) $(LIBS) +.cc.o: + $(CXXCOMPILE) -c $< + +install-dataDATA: $(data_DATA) + @$(NORMAL_INSTALL) + $(mkinstalldirs) $(DESTDIR)$(datadir) + @list='$(data_DATA)'; for p in $$list; do \ + if test -f $(srcdir)/$$p; then \ + echo " $(INSTALL_DATA) $(srcdir)/$$p $(DESTDIR)$(datadir)/$$p"; \ + $(INSTALL_DATA) $(srcdir)/$$p $(DESTDIR)$(datadir)/$$p; \ + else if test -f $$p; then \ + echo " $(INSTALL_DATA) $$p $(DESTDIR)$(datadir)/$$p"; \ + $(INSTALL_DATA) $$p $(DESTDIR)$(datadir)/$$p; \ + fi; fi; \ + done + +uninstall-dataDATA: + @$(NORMAL_UNINSTALL) + list='$(data_DATA)'; for p in $$list; do \ + rm -f $(DESTDIR)$(datadir)/$$p; \ + done + +# This directory's subdirectories are mostly independent; you can cd +# into them and run `make' without going through this Makefile. +# To change the values of `make' variables: instead of editing Makefiles, +# (1) if the variable is set in `config.status', edit `config.status' +# (which will cause the Makefiles to be regenerated when you run `make'); +# (2) otherwise, pass the desired values on the `make' command line. + +@SET_MAKE@ + +all-recursive install-data-recursive install-exec-recursive \ +installdirs-recursive install-recursive uninstall-recursive install-info-recursive \ +check-recursive installcheck-recursive info-recursive dvi-recursive: + @set fnord $(MAKEFLAGS); amf=$$2; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" + +mostlyclean-recursive clean-recursive distclean-recursive \ +maintainer-clean-recursive: + @set fnord $(MAKEFLAGS); amf=$$2; \ + dot_seen=no; \ + rev=''; list='$(SUBDIRS)'; for subdir in $$list; do \ + rev="$$subdir $$rev"; \ + test "$$subdir" = "." && dot_seen=yes; \ + done; \ + test "$$dot_seen" = "no" && rev=". $$rev"; \ + target=`echo $@ | sed s/-recursive//`; \ + for subdir in $$rev; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \ + done && test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done + +tags: TAGS + +ID: $(HEADERS) $(SOURCES) $(LISP) + list='$(SOURCES) $(HEADERS)'; \ + unique=`for i in $$list; do echo $$i; done | \ + awk ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + here=`pwd` && cd $(srcdir) \ + && mkid -f$$here/ID $$unique $(LISP) + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test -f $$subdir/TAGS && tags="$$tags -i $$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS)'; \ + unique=`for i in $$list; do echo $$i; done | \ + awk ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \ + || (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS) + +mostlyclean-tags: + +clean-tags: + +distclean-tags: + -rm -f TAGS ID + +maintainer-clean-tags: + +distdir = $(PACKAGE)-$(VERSION) +top_distdir = $(distdir) + +# This target untars the dist file and tries a VPATH configuration. Then +# it guarantees that the distribution is self-contained by making another +# tarfile. +distcheck: dist + -rm -rf $(distdir) + GZIP=$(GZIP_ENV) $(TAR) zxf $(distdir).tar.gz + mkdir $(distdir)/=build + mkdir $(distdir)/=inst + dc_install_base=`cd $(distdir)/=inst && pwd`; \ + cd $(distdir)/=build \ + && ../configure --srcdir=.. --prefix=$$dc_install_base \ + && $(MAKE) $(AM_MAKEFLAGS) \ + && $(MAKE) $(AM_MAKEFLAGS) dvi \ + && $(MAKE) $(AM_MAKEFLAGS) check \ + && $(MAKE) $(AM_MAKEFLAGS) install \ + && $(MAKE) $(AM_MAKEFLAGS) installcheck \ + && $(MAKE) $(AM_MAKEFLAGS) dist + -rm -rf $(distdir) + @banner="$(distdir).tar.gz is ready for distribution"; \ + dashes=`echo "$$banner" | sed s/./=/g`; \ + echo "$$dashes"; \ + echo "$$banner"; \ + echo "$$dashes" +dist: distdir + -chmod -R a+r $(distdir) + GZIP=$(GZIP_ENV) $(TAR) chozf $(distdir).tar.gz $(distdir) + -rm -rf $(distdir) +dist-all: distdir + -chmod -R a+r $(distdir) + GZIP=$(GZIP_ENV) $(TAR) chozf $(distdir).tar.gz $(distdir) + -rm -rf $(distdir) +distdir: $(DISTFILES) + -rm -rf $(distdir) + mkdir $(distdir) + -chmod 777 $(distdir) + here=`cd $(top_builddir) && pwd`; \ + top_distdir=`cd $(distdir) && pwd`; \ + distdir=`cd $(distdir) && pwd`; \ + cd $(top_srcdir) \ + && $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --foreign Makefile + @for file in $(DISTFILES); do \ + d=$(srcdir); \ + if test -d $$d/$$file; then \ + cp -pr $$/$$file $(distdir)/$$file; \ + else \ + test -f $(distdir)/$$file \ + || ln $$d/$$file $(distdir)/$$file 2> /dev/null \ + || cp -p $$d/$$file $(distdir)/$$file || :; \ + fi; \ + done + for subdir in $(DIST_SUBDIRS); do \ + if test "$$subdir" = .; then :; else \ + test -d $(distdir)/$$subdir \ + || mkdir $(distdir)/$$subdir \ + || exit 1; \ + chmod 777 $(distdir)/$$subdir; \ + (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir=../$(distdir) distdir=../$(distdir)/$$subdir distdir) \ + || exit 1; \ + fi; \ + done + +DEPS_MAGIC := $(shell mkdir .deps > /dev/null 2>&1 || :) + +-include $(DEP_FILES) + +mostlyclean-depend: + +clean-depend: + +distclean-depend: + -rm -rf .deps + +maintainer-clean-depend: + +%.o: %.c + @echo '$(COMPILE) -c $<'; \ + $(COMPILE) -Wp,-MD,.deps/$(*F).pp -c $< + @-cp .deps/$(*F).pp .deps/$(*F).P; \ + tr ' ' '\012' < .deps/$(*F).pp \ + | sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \ + >> .deps/$(*F).P; \ + rm .deps/$(*F).pp + +%.lo: %.c + @echo '$(LTCOMPILE) -c $<'; \ + $(LTCOMPILE) -Wp,-MD,.deps/$(*F).pp -c $< + @-sed -e 's/^\([^:]*\)\.o[ ]*:/\1.lo \1.o :/' \ + < .deps/$(*F).pp > .deps/$(*F).P; \ + tr ' ' '\012' < .deps/$(*F).pp \ + | sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \ + >> .deps/$(*F).P; \ + rm -f .deps/$(*F).pp + +%.o: %.cc + @echo '$(CXXCOMPILE) -c $<'; \ + $(CXXCOMPILE) -Wp,-MD,.deps/$(*F).pp -c $< + @-cp .deps/$(*F).pp .deps/$(*F).P; \ + tr ' ' '\012' < .deps/$(*F).pp \ + | sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \ + >> .deps/$(*F).P; \ + rm .deps/$(*F).pp + +%.lo: %.cc + @echo '$(LTCXXCOMPILE) -c $<'; \ + $(LTCXXCOMPILE) -Wp,-MD,.deps/$(*F).pp -c $< + @-sed -e 's/^\([^:]*\)\.o[ ]*:/\1.lo \1.o :/' \ + < .deps/$(*F).pp > .deps/$(*F).P; \ + tr ' ' '\012' < .deps/$(*F).pp \ + | sed -e 's/^\\$$//' -e '/^$$/ d' -e '/:$$/ d' -e 's/$$/ :/' \ + >> .deps/$(*F).P; \ + rm -f .deps/$(*F).pp +info-am: +info: info-recursive +dvi-am: +dvi: dvi-recursive +check-am: all-am +check: check-recursive +installcheck-am: +installcheck: installcheck-recursive +install-info-am: +install-info: install-info-recursive +install-exec-am: install-toolexeclibLIBRARIES install-binPROGRAMS +install-exec: install-exec-recursive + +install-data-am: install-dataDATA +install-data: install-data-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am +install: install-recursive +uninstall-am: uninstall-toolexeclibLIBRARIES uninstall-binPROGRAMS \ + uninstall-dataDATA +uninstall: uninstall-recursive +all-am: Makefile $(LIBRARIES) $(PROGRAMS) $(DATA) +all-redirect: all-recursive +install-strip: + $(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install +installdirs: installdirs-recursive +installdirs-am: + $(mkinstalldirs) $(DESTDIR)$(toolexeclibdir) $(DESTDIR)$(bindir) \ + $(DESTDIR)$(datadir) + + +mostlyclean-generic: + -test -z "$(MOSTLYCLEANFILES)" || rm -f $(MOSTLYCLEANFILES) + +clean-generic: + -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) + +distclean-generic: + -rm -f Makefile $(CONFIG_CLEAN_FILES) + -rm -f config.cache config.log stamp-h stamp-h[0-9]* + +maintainer-clean-generic: +mostlyclean-am: mostlyclean-hdr mostlyclean-toolexeclibLIBRARIES \ + mostlyclean-compile mostlyclean-binPROGRAMS \ + mostlyclean-noinstPROGRAMS mostlyclean-tags \ + mostlyclean-depend mostlyclean-generic + +mostlyclean: mostlyclean-recursive + +clean-am: clean-hdr clean-toolexeclibLIBRARIES clean-compile \ + clean-binPROGRAMS clean-noinstPROGRAMS clean-tags \ + clean-depend clean-generic mostlyclean-am + +clean: clean-recursive + +distclean-am: distclean-hdr distclean-toolexeclibLIBRARIES \ + distclean-compile distclean-binPROGRAMS \ + distclean-noinstPROGRAMS distclean-tags \ + distclean-depend distclean-generic clean-am + +distclean: distclean-recursive + -rm -f config.status + +maintainer-clean-am: maintainer-clean-hdr \ + maintainer-clean-toolexeclibLIBRARIES \ + maintainer-clean-compile maintainer-clean-binPROGRAMS \ + maintainer-clean-noinstPROGRAMS maintainer-clean-tags \ + maintainer-clean-depend maintainer-clean-generic \ + distclean-am + @echo "This command is intended for maintainers to use;" + @echo "it deletes files that may require special tools to rebuild." + +maintainer-clean: maintainer-clean-recursive + -rm -f config.status + +.PHONY: mostlyclean-hdr distclean-hdr clean-hdr maintainer-clean-hdr \ +mostlyclean-toolexeclibLIBRARIES distclean-toolexeclibLIBRARIES \ +clean-toolexeclibLIBRARIES maintainer-clean-toolexeclibLIBRARIES \ +uninstall-toolexeclibLIBRARIES install-toolexeclibLIBRARIES \ +mostlyclean-compile distclean-compile clean-compile \ +maintainer-clean-compile mostlyclean-binPROGRAMS distclean-binPROGRAMS \ +clean-binPROGRAMS maintainer-clean-binPROGRAMS uninstall-binPROGRAMS \ +install-binPROGRAMS mostlyclean-noinstPROGRAMS distclean-noinstPROGRAMS \ +clean-noinstPROGRAMS maintainer-clean-noinstPROGRAMS uninstall-dataDATA \ +install-dataDATA install-data-recursive uninstall-data-recursive \ +install-exec-recursive uninstall-exec-recursive installdirs-recursive \ +uninstalldirs-recursive all-recursive check-recursive \ +installcheck-recursive info-recursive dvi-recursive \ +mostlyclean-recursive distclean-recursive clean-recursive \ +maintainer-clean-recursive tags tags-recursive mostlyclean-tags \ +distclean-tags clean-tags maintainer-clean-tags distdir \ +mostlyclean-depend distclean-depend clean-depend \ +maintainer-clean-depend info-am info dvi-am dvi check check-am \ +installcheck-am installcheck install-info-am install-info \ +install-exec-am install-exec install-data-am install-data install-am \ +install uninstall-am uninstall all-redirect all-am all installdirs-am \ +installdirs mostlyclean-generic distclean-generic clean-generic \ +maintainer-clean-generic clean mostlyclean distclean maintainer-clean + + +$(java_source_files:.java=.class): libgcj.zip + +libgcj.zip: $(java_source_files) + javac="$(JAVAC)"; cd $(srcdir); \ + $$javac $(JCFLAGS) -classpath $(here):`/bin/pwd` -d $(here) \ + $(subst $(srcdir)/,,$?) + -@rm -f libgcj.zip + $(ZIP) -r libgcj java -n .class -i '*.class' -i '*/' + +.class.o: + CLASSPATH=$(here) $(CC) -fassume-compiled $(JC1FLAGS) -c -o $@ $< + +.java.o: + CLASSPATH=$(here) $(GCJ) -fassume-compiled $(JC1FLAGS) -c -o $@ $< + +$(nat_files): %.o: %.cc + $(CXXCOMPILE) -c -o $@ $< + +$(nat_files) $(GCOBJS) $(THREADOBJS) $(libgcj_a_OBJECTS): \ + include/config.h $(nat_headers) + +$(c_files): %.o: %.c + $(COMPILE) -c -o $@ $< + +$(c_files): java/lang/fdlibm.h java/lang/ieeefp.h java/lang/mprec.h + +$(javao_files): %.o: %.java + CLASSPATH=$(here) $(GCJ) -fassume-compiled $(JC1FLAGS) -c -o $@ $< + +.class.h: + $(GCJH) -classpath $(top_builddir) $(basename $<) + +$(nat_headers): libgcj.zip +java/lang/FirstThread.h: java/lang/FirstThread.class libgcj.zip + $(GCJH) -classpath $(top_builddir) -friend '$(FTFRIEND);' \ + $(basename $<) +java/lang/ThreadGroup.h: java/lang/ThreadGroup.class libgcj.zip + $(GCJH) -classpath $(top_builddir) -friend '$(TGFRIEND);' \ + $(basename $<) + +java/lang/String.h: java/lang/String.class libgcj.zip + $(GCJH) -classpath $(top_builddir) \ + -friend 'jchar* _Jv_GetStringChars (jstring str);' \ + -friend 'jstring* _Jv_StringFindSlot (jchar*, jint, jint);' \ + -friend 'jstring* _Jv_StringGetSlot (jstring);' \ + -friend 'jstring _Jv_NewStringUtf8Const (_Jv_Utf8Const* str);' \ + -friend 'jstring _Jv_NewStringLatin1 (const char*, jsize);' \ + -friend 'jstring _Jv_AllocString (jsize);' \ + $(basename $<) + +java/lang/reflect/Field.h: java/lang/reflect/Field.class libgcj.zip + $(GCJH) -classpath $(top_builddir) \ + -friend 'jfieldID _Jv_FromReflectedField (java::lang::reflect::Field *);' \ + -friend 'jobject _Jv_JNI_ToReflectedField (_Jv_JNIEnv*, jclass, jfieldID);' \ + -friend 'java::lang::Class;' \ + $(basename $<) + +java/lang/reflect/Method.h: java/lang/reflect/Method.class libgcj.zip + $(GCJH) -classpath $(top_builddir) \ + -friend 'jmethodID _Jv_FromReflectedMethod (java::lang::reflect::Method *);' \ + -friend 'java::lang::Class;' \ + $(basename $<) + +maintainer-check: libgcj.a + $(NM) libgcj.a | grep ' T ' \ + | grep -v '4java' \ + | grep -v 'Jv' \ + | grep -v 'terminate__Fv' | grep -v 'unexpected__Fv' + +header-check: libgcj.zip $(nat_headers) + rm -f htest.cc; \ + for h in $(nat_headers); do \ + echo "#include \"$$h\"" >> htest.cc; \ + done; \ + $(CXXCOMPILE) -fsyntax-only htest.cc + +# The Unicode consortium does not permit re-distributing the file JIS0208.TXT. +# You can get it from ftp://ftp.unicode.org/Public/MAPPINGS/EASTASIA/JIS/. + +$(srcdir)/$(CONVERT_DIR)/JIS0208.h: # JIS0208.TXT + echo '/* This file is autoamtically generated from Unicode tables */' > tmp-0208; \ + sed -n -e 's|\(0x....\).*0x\(..\)\(..\).*\(0x....\).*#\(.*\).$$|MAP(0x\2, 0x\3, \4) /*\5 */|p' \ + > tmp-0208; \ + mv tmp-0208 $(srcdir)/$(CONVERT_DIR)/JIS0208.h + +# The Unicode consortium does not permit re-distributing the file JIS0212.TXT. +# You can get it from ftp://ftp.unicode.org/Public/MAPPINGS/EASTASIA/JIS/. + +$(srcdir)/$(CONVERT_DIR)/JIS0212.h: # JIS0212.TXT + echo '/* This file is autoamtically generated from Unicode tables */' > tmp-0212; \ + sed -n -e 's|0x\(..\)\(..\).*\(0x....\).*#\(.*\).$$|MAP(0x\1, 0x\2, \3) /*\4 */|p' \ + > tmp-0212; \ + mv tmp-0212 $(srcdir)/$(CONVERT_DIR)/JIS0212.h + +$(CONVERT_DIR)/gen-from-JIS.o: $(srcdir)/$(CONVERT_DIR)/gen-from-JIS.c \ + $(srcdir)/$(CONVERT_DIR)/JIS0208.h \ + $(srcdir)/$(CONVERT_DIR)/JIS0212.h + $(COMPILE) -c -o $(CONVERT_DIR)/gen-from-JIS.o \ + $(srcdir)/$(CONVERT_DIR)/gen-from-JIS.c + +@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@$(srcdir)/$(CONVERT_DIR)/JIS0208_to_Unicode.cc: ./gen-from-JIS$(EXEEXT) +@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@ ./gen-from-JIS JIS0208>$(srcdir)/$(CONVERT_DIR)/JIS0208_to_Unicode.cc + +@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@$(srcdir)/$(CONVERT_DIR)/JIS0212_to_Unicode.cc: ./gen-from-JIS$(EXEEXT) +@NATIVE_TRUE@@MAINTAINER_MODE_TRUE@ ./gen-from-JIS JIS0212>$(srcdir)/$(CONVERT_DIR)/JIS0212_to_Unicode.cc + +# Multilib support. +.PHONY: all-multi mostlyclean-multi clean-multi distclean-multi \ + maintainer-clean-multi + +all-recursive: all-multi +install-recursive: install-multi +mostlyclean-recursive: mostlyclean-multi +clean-recursive: clean-multi +distclean-recursive: distclean-multi +maintainer-clean-recursive: maintainer-clean-multi + +all-multi: + $(MULTIDO) $(AM_MAKEFLAGS) DO=all multi-do +install-multi: + $(MULTIDO) $(AM_MAKEFLAGS) DO=install multi-do +mostlyclean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=mostlyclean multi-clean +clean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=clean multi-clean +distclean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=distclean multi-clean +maintainer-clean-multi: + $(MULTICLEAN) $(AM_MAKEFLAGS) DO=maintainer-clean multi-clean + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/libjava/acconfig.h b/libjava/acconfig.h new file mode 100644 index 00000000000..11a7c3787e3 --- /dev/null +++ b/libjava/acconfig.h @@ -0,0 +1,89 @@ +/* Name of this package. */ +#undef PACKAGE + +/* Version number of this package. */ +#undef VERSION + +/* Define this if you want runtime debugging enabled. */ +#undef DEBUG + +/* Define if using POSIX threads that have the mutexattr functions. */ +#undef HAVE_PTHREAD_MUTEXATTR_INIT + +/* Define this if you prefer size over speed for java.lang.Character. */ +#undef COMPACT_CHARACTER + +/* Define if you have memcpy. */ +#undef HAVE_MEMCPY + +/* Define if you have memmove. */ +#undef HAVE_MEMMOVE + +/* Define if you have strerror. */ +#undef HAVE_STRERROR + +/* Define if you have fsync. */ +#undef HAVE_FSYNC + +/* Define if you have sleep. */ +#undef HAVE_SLEEP + +/* Define if you have __int32_t and __uint32_t. */ +#undef HAVE_INT32_DEFINED + +/* Define if you're running eCos. */ +#undef ECOS + +/* */ +#undef HAVE_LOCALTIME + +/* */ +#undef HAVE_MKTIME + +/* Define if using POSIX threads on Linux. */ +#undef LINUX_THREADS + +/* Define if you have the `ctime_r' function. */ +#undef HAVE_CTIME_R + +/* Define if you have the `gmtime_r' function. */ +#undef HAVE_GMTIME_R + +/* Define if you have the `localtime_r' function. */ +#undef HAVE_LOCALTIME_R + +/* Define if inet6 structures are defined in netinet/in.h. */ +#undef HAVE_INET6 + +/* Define it socklen_t typedef is in sys/socket.h. */ +#undef HAVE_SOCKLEN_T + +/* Define if Boehm GC in use. */ +#undef HAVE_BOEHM_GC + +/* Define if gethostname is declared in . */ +#undef HAVE_GETHOSTNAME_DECL + +/* Define if gethostbyname_r returns `int'. */ +#undef GETHOSTBYNAME_R_RETURNS_INT + +/* Define if gethostbyaddr_r returns `int'. */ +#undef GETHOSTBYADDR_R_RETURNS_INT + +/* Define if struct tm has tm_gmtoff field. */ +#undef STRUCT_TM_HAS_GMTOFF + +/* Define if global `timezone' exists. */ +#undef HAVE_TIMEZONE + +/* Define if you have the appropriate function. */ +#undef HAVE_ACCESS +#undef HAVE_STAT +#undef HAVE_MKDIR +#undef HAVE_RENAME +#undef HAVE_RMDIR +#undef HAVE_UNLINK +#undef HAVE_REALPATH +#undef HAVE_READDIR_R +#undef HAVE_GETHOSTBYNAME_R +#undef HAVE_GETHOSTBYADDR_R diff --git a/libjava/acinclude.m4 b/libjava/acinclude.m4 new file mode 100644 index 00000000000..2056b9f9b77 --- /dev/null +++ b/libjava/acinclude.m4 @@ -0,0 +1,156 @@ +# FIXME: We temporarily define our own version of AC_PROG_CC. This is +# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We +# are probably using a cross compiler, which will not be able to fully +# link an executable. This should really be fixed in autoconf +# itself. + +AC_DEFUN(LIBGCJ_CONFIGURE, +[ +dnl Default to --enable-multilib +AC_ARG_ENABLE(multilib, +[ --enable-multilib build many library versions (default)], +[case "${enableval}" in + yes) multilib=yes ;; + no) multilib=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for multilib option) ;; + esac], [multilib=yes])dnl + +dnl We may get other options which we dont document: +dnl --with-target-subdir, --with-multisrctop, --with-multisubdir + +if test "[$]{srcdir}" = "."; then + if test "[$]{with_target_subdir}" != "."; then + libgcj_basedir="[$]{srcdir}/[$]{with_multisrctop}../$1" + else + libgcj_basedir="[$]{srcdir}/[$]{with_multisrctop}$1" + fi +else + libgcj_basedir="[$]{srcdir}/$1" +fi +AC_SUBST(libgcj_basedir) + +AC_CANONICAL_HOST + +dnl Still use "libjava" here to placate dejagnu. +AM_INIT_AUTOMAKE(libjava, 0.0.7) + +# FIXME: We temporarily define our own version of AC_PROG_CC. This is +# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We +# are probably using a cross compiler, which will not be able to fully +# link an executable. This should really be fixed in autoconf +# itself. + +AC_DEFUN(LIB_AC_PROG_CC, +[AC_BEFORE([$0], [AC_PROG_CPP])dnl +AC_CHECK_PROG(CC, gcc, gcc) +if test -z "$CC"; then + AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) + test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH]) +fi + +AC_PROG_CC_GNU + +if test $ac_cv_prog_gcc = yes; then + GCC=yes +dnl Check whether -g works, even if CFLAGS is set, in case the package +dnl plays around with CFLAGS (such as to build both debugging and +dnl normal versions of a library), tasteless as that idea is. + ac_test_CFLAGS="${CFLAGS+set}" + ac_save_CFLAGS="$CFLAGS" + CFLAGS= + AC_PROG_CC_G + if test "$ac_test_CFLAGS" = set; then + CFLAGS="$ac_save_CFLAGS" + elif test $ac_cv_prog_cc_g = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-O2" + fi +else + GCC= + test "${CFLAGS+set}" = set || CFLAGS="-g" +fi +]) + +LIB_AC_PROG_CC + +# Likewise for AC_PROG_CXX. +AC_DEFUN(LIB_AC_PROG_CXX, +[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl +AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++, gcc) +test -z "$CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH]) + +AC_PROG_CXX_GNU + +if test $ac_cv_prog_gxx = yes; then + GXX=yes +dnl Check whether -g works, even if CXXFLAGS is set, in case the package +dnl plays around with CXXFLAGS (such as to build both debugging and +dnl normal versions of a library), tasteless as that idea is. + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS= + AC_PROG_CXX_G + if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS="$ac_save_CXXFLAGS" + elif test $ac_cv_prog_cxx_g = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-O2" + fi +else + GXX= + test "${CXXFLAGS+set}" = set || CXXFLAGS="-g" +fi +]) + +LIB_AC_PROG_CXX + +# AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD). If we dont +# run it explicitly here, it will be run implicitly before +# LIBGCJ_CONFIGURE, which doesn't work because that means that it will +# be run before AC_CANONICAL_HOST. +AC_CANONICAL_BUILD + +AC_CHECK_TOOL(AS, as) +AC_CHECK_TOOL(AR, ar) +AC_CHECK_TOOL(RANLIB, ranlib, :) + +AC_PROG_INSTALL + +AM_MAINTAINER_MODE + +# We need AC_EXEEXT to keep automake happy in cygnus mode. However, +# at least currently, we never actually build a program, so we never +# need to use $(EXEEXT). Moreover, the test for EXEEXT normally +# fails, because we are probably configuring with a cross compiler +# which cant create executables. So we include AC_EXEEXT to keep +# automake happy, but we dont execute it, since we dont care about +# the result. +if false; then + AC_EXEEXT +fi + +# configure.host sets the following important variables +# libgcj_cflags - host specific C compiler flags +# libgcj_cxxflags - host specific C++ compiler flags +# libgcj_javaflags - host specific Java compiler flags + +libgcj_cflags= +libgcj_cxxflags= +libgcj_javaflags= + +. [$]{libgcj_basedir}/configure.host + +case [$]{libgcj_basedir} in +/* | [A-Za-z]:[/\\]*) libgcj_flagbasedir=[$]{libgcj_basedir} ;; +*) libgcj_flagbasedir='[$](top_builddir)/'[$]{libgcj_basedir} ;; +esac + +LIBGCJ_CFLAGS="[$]{libgcj_cflags}" +LIBGCJ_CXXFLAGS="[$]{libgcj_cxxflags}" +LIBGCJ_JAVAFLAGS="[$]{libgcj_javaflags}" +AC_SUBST(LIBGCJ_CFLAGS) +AC_SUBST(LIBGCJ_CXXFLAGS) +AC_SUBST(LIBGCJ_JAVAFLAGS) +])dnl diff --git a/libjava/aclocal.m4 b/libjava/aclocal.m4 new file mode 100644 index 00000000000..651dd93fc24 --- /dev/null +++ b/libjava/aclocal.m4 @@ -0,0 +1,317 @@ +dnl aclocal.m4 generated automatically by aclocal 1.4 + +dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl This program is distributed in the hope that it will be useful, +dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without +dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A +dnl PARTICULAR PURPOSE. + +# FIXME: We temporarily define our own version of AC_PROG_CC. This is +# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We +# are probably using a cross compiler, which will not be able to fully +# link an executable. This should really be fixed in autoconf +# itself. + +AC_DEFUN(LIBGCJ_CONFIGURE, +[ +dnl Default to --enable-multilib +AC_ARG_ENABLE(multilib, +[ --enable-multilib build many library versions (default)], +[case "${enableval}" in + yes) multilib=yes ;; + no) multilib=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for multilib option) ;; + esac], [multilib=yes])dnl + +dnl We may get other options which we dont document: +dnl --with-target-subdir, --with-multisrctop, --with-multisubdir + +if test "[$]{srcdir}" = "."; then + if test "[$]{with_target_subdir}" != "."; then + libgcj_basedir="[$]{srcdir}/[$]{with_multisrctop}../$1" + else + libgcj_basedir="[$]{srcdir}/[$]{with_multisrctop}$1" + fi +else + libgcj_basedir="[$]{srcdir}/$1" +fi +AC_SUBST(libgcj_basedir) + +AC_CANONICAL_HOST + +dnl Still use "libjava" here to placate dejagnu. +AM_INIT_AUTOMAKE(libjava, 0.0.7) + +# FIXME: We temporarily define our own version of AC_PROG_CC. This is +# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We +# are probably using a cross compiler, which will not be able to fully +# link an executable. This should really be fixed in autoconf +# itself. + +AC_DEFUN(LIB_AC_PROG_CC, +[AC_BEFORE([$0], [AC_PROG_CPP])dnl +AC_CHECK_PROG(CC, gcc, gcc) +if test -z "$CC"; then + AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) + test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH]) +fi + +AC_PROG_CC_GNU + +if test $ac_cv_prog_gcc = yes; then + GCC=yes +dnl Check whether -g works, even if CFLAGS is set, in case the package +dnl plays around with CFLAGS (such as to build both debugging and +dnl normal versions of a library), tasteless as that idea is. + ac_test_CFLAGS="${CFLAGS+set}" + ac_save_CFLAGS="$CFLAGS" + CFLAGS= + AC_PROG_CC_G + if test "$ac_test_CFLAGS" = set; then + CFLAGS="$ac_save_CFLAGS" + elif test $ac_cv_prog_cc_g = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-O2" + fi +else + GCC= + test "${CFLAGS+set}" = set || CFLAGS="-g" +fi +]) + +LIB_AC_PROG_CC + +# Likewise for AC_PROG_CXX. +AC_DEFUN(LIB_AC_PROG_CXX, +[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl +AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++, gcc) +test -z "$CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH]) + +AC_PROG_CXX_GNU + +if test $ac_cv_prog_gxx = yes; then + GXX=yes +dnl Check whether -g works, even if CXXFLAGS is set, in case the package +dnl plays around with CXXFLAGS (such as to build both debugging and +dnl normal versions of a library), tasteless as that idea is. + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS= + AC_PROG_CXX_G + if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS="$ac_save_CXXFLAGS" + elif test $ac_cv_prog_cxx_g = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-O2" + fi +else + GXX= + test "${CXXFLAGS+set}" = set || CXXFLAGS="-g" +fi +]) + +LIB_AC_PROG_CXX + +# AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD). If we dont +# run it explicitly here, it will be run implicitly before +# LIBGCJ_CONFIGURE, which doesn't work because that means that it will +# be run before AC_CANONICAL_HOST. +AC_CANONICAL_BUILD + +AC_CHECK_TOOL(AS, as) +AC_CHECK_TOOL(AR, ar) +AC_CHECK_TOOL(RANLIB, ranlib, :) + +AC_PROG_INSTALL + +AM_MAINTAINER_MODE + +# We need AC_EXEEXT to keep automake happy in cygnus mode. However, +# at least currently, we never actually build a program, so we never +# need to use $(EXEEXT). Moreover, the test for EXEEXT normally +# fails, because we are probably configuring with a cross compiler +# which cant create executables. So we include AC_EXEEXT to keep +# automake happy, but we dont execute it, since we dont care about +# the result. +if false; then + AC_EXEEXT +fi + +# configure.host sets the following important variables +# libgcj_cflags - host specific C compiler flags +# libgcj_cxxflags - host specific C++ compiler flags +# libgcj_javaflags - host specific Java compiler flags + +libgcj_cflags= +libgcj_cxxflags= +libgcj_javaflags= + +. [$]{libgcj_basedir}/configure.host + +case [$]{libgcj_basedir} in +/* | [A-Za-z]:[/\\]*) libgcj_flagbasedir=[$]{libgcj_basedir} ;; +*) libgcj_flagbasedir='[$](top_builddir)/'[$]{libgcj_basedir} ;; +esac + +LIBGCJ_CFLAGS="[$]{libgcj_cflags}" +LIBGCJ_CXXFLAGS="[$]{libgcj_cxxflags}" +LIBGCJ_JAVAFLAGS="[$]{libgcj_javaflags}" +AC_SUBST(LIBGCJ_CFLAGS) +AC_SUBST(LIBGCJ_CXXFLAGS) +AC_SUBST(LIBGCJ_JAVAFLAGS) +])dnl + +# Do all the work for Automake. This macro actually does too much -- +# some checks are only needed if your package does certain things. +# But this isn't really a big deal. + +# serial 1 + +dnl Usage: +dnl AM_INIT_AUTOMAKE(package,version, [no-define]) + +AC_DEFUN(AM_INIT_AUTOMAKE, +[AC_REQUIRE([AC_PROG_INSTALL]) +PACKAGE=[$1] +AC_SUBST(PACKAGE) +VERSION=[$2] +AC_SUBST(VERSION) +dnl test to see if srcdir already configured +if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then + AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) +fi +ifelse([$3],, +AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package]) +AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])) +AC_REQUIRE([AM_SANITY_CHECK]) +AC_REQUIRE([AC_ARG_PROGRAM]) +dnl FIXME This is truly gross. +missing_dir=`cd $ac_aux_dir && pwd` +AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir) +AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir) +AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir) +AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir) +AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir) +AC_REQUIRE([AC_PROG_MAKE_SET])]) + +# +# Check to make sure that the build environment is sane. +# + +AC_DEFUN(AM_SANITY_CHECK, +[AC_MSG_CHECKING([whether build environment is sane]) +# Just in case +sleep 1 +echo timestamp > conftestfile +# Do `set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null` + if test "[$]*" = "X"; then + # -L didn't work. + set X `ls -t $srcdir/configure conftestfile` + fi + if test "[$]*" != "X $srcdir/configure conftestfile" \ + && test "[$]*" != "X conftestfile $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken +alias in your environment]) + fi + + test "[$]2" = conftestfile + ) +then + # Ok. + : +else + AC_MSG_ERROR([newly created file is older than distributed files! +Check your system clock]) +fi +rm -f conftest* +AC_MSG_RESULT(yes)]) + +dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY) +dnl The program must properly implement --version. +AC_DEFUN(AM_MISSING_PROG, +[AC_MSG_CHECKING(for working $2) +# Run test in a subshell; some versions of sh will print an error if +# an executable is not found, even if stderr is redirected. +# Redirect stdin to placate older versions of autoconf. Sigh. +if ($2 --version) < /dev/null > /dev/null 2>&1; then + $1=$2 + AC_MSG_RESULT(found) +else + $1="$3/missing $2" + AC_MSG_RESULT(missing) +fi +AC_SUBST($1)]) + +# Add --enable-maintainer-mode option to configure. +# From Jim Meyering + +# serial 1 + +AC_DEFUN(AM_MAINTAINER_MODE, +[AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles]) + dnl maintainer-mode is disabled by default + AC_ARG_ENABLE(maintainer-mode, +[ --enable-maintainer-mode enable make rules and dependencies not useful + (and sometimes confusing) to the casual installer], + USE_MAINTAINER_MODE=$enableval, + USE_MAINTAINER_MODE=no) + AC_MSG_RESULT($USE_MAINTAINER_MODE) + AM_CONDITIONAL(MAINTAINER_MODE, test $USE_MAINTAINER_MODE = yes) + MAINT=$MAINTAINER_MODE_TRUE + AC_SUBST(MAINT)dnl +] +) + +# Define a conditional. + +AC_DEFUN(AM_CONDITIONAL, +[AC_SUBST($1_TRUE) +AC_SUBST($1_FALSE) +if $2; then + $1_TRUE= + $1_FALSE='#' +else + $1_TRUE='#' + $1_FALSE= +fi]) + +# Like AC_CONFIG_HEADER, but automatically create stamp file. + +AC_DEFUN(AM_CONFIG_HEADER, +[AC_PREREQ([2.12]) +AC_CONFIG_HEADER([$1]) +dnl When config.status generates a header, we must update the stamp-h file. +dnl This file resides in the same directory as the config header +dnl that is generated. We must strip everything past the first ":", +dnl and everything past the last "/". +AC_OUTPUT_COMMANDS(changequote(<<,>>)dnl +ifelse(patsubst(<<$1>>, <<[^ ]>>, <<>>), <<>>, +<>CONFIG_HEADERS" || echo timestamp > patsubst(<<$1>>, <<^\([^:]*/\)?.*>>, <<\1>>)stamp-h<<>>dnl>>, +<>; do + case " <<$>>CONFIG_HEADERS " in + *" <<$>>am_file "*<<)>> + echo timestamp > `echo <<$>>am_file | sed -e 's%:.*%%' -e 's%[^/]*$%%'`stamp-h$am_indx + ;; + esac + am_indx=`expr "<<$>>am_indx" + 1` +done<<>>dnl>>) +changequote([,]))]) + diff --git a/libjava/boehm.cc b/libjava/boehm.cc new file mode 100644 index 00000000000..c41dab94387 --- /dev/null +++ b/libjava/boehm.cc @@ -0,0 +1,367 @@ +// boehm.cc - interface between libjava and Boehm GC. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include + +#include +#include +#include +#include + +// We need to include gc_priv.h. However, it tries to include +// config.h if it hasn't already been included. So we force the +// inclusion of the Boehm config.h. +extern "C" +{ +#include +#include +#include + + // These aren't declared in any Boehm GC header. + void GC_finalize_all (void); + ptr_t GC_debug_generic_malloc (size_t size, int k, GC_EXTRA_PARAMS); +}; + +// FIXME: this should probably be defined in some GC header. +#ifdef GC_DEBUG +# define GC_GENERIC_MALLOC(Size, Type) \ + GC_debug_generic_malloc (Size, Type, GC_EXTRAS) +#else +# define GC_GENERIC_MALLOC(Size, Type) GC_generic_malloc (Size, Type) +#endif + +// We must check for plausibility ourselves. +#define MAYBE_MARK(Obj, Top, Limit, Source, Exit) \ + if ((ptr_t) (Obj) >= GC_least_plausible_heap_addr \ + && (ptr_t) (Obj) <= GC_greatest_plausible_heap_addr) \ + PUSH_CONTENTS (Obj, Top, Limit, Source, Exit) + +#define ObjectClass _CL_Q34java4lang6Object +extern java::lang::Class ObjectClass; +#define ClassClass _CL_Q34java4lang5Class +extern java::lang::Class ClassClass; + + + +// Nonzero if this module has been initialized. +static int initialized = 0; + +// `kind' index used when allocating Java objects. +static int obj_kind_x; + +// `kind' index used when allocating Java arrays. +static int array_kind_x; + +// Freelist used for Java objects. +static ptr_t *obj_free_list; + +// Freelist used for Java arrays. +static ptr_t *array_free_list; + + + +// This is called by the GC during the mark phase. It marks a Java +// object. We use `void *' arguments and return, and not what the +// Boehm GC wants, to avoid pollution in our headers. +void * +_Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/) +{ + mse *mark_stack_ptr = (mse *) msp; + mse *mark_stack_limit = (mse *) msl; + jobject obj = (jobject) addr; + + _Jv_VTable *dt = *(_Jv_VTable **) addr; + // We check this in case a GC occurs before the vtbl is set. FIXME: + // should use allocation lock while initializing object. + if (! dt) + return mark_stack_ptr; + jclass klass = dt->clas; + + // Every object has a sync_info pointer. + word w = (word) obj->sync_info; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, obj, o1label); + // Mark the object's class. + w = (word) klass; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, obj, o2label); + + if (klass == &ClassClass) + { + jclass c = (jclass) addr; + + w = (word) c->next; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c2label); + w = (word) c->name; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c3label); + w = (word) c->superclass; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c4label); + for (int i = 0; i < c->constants.size; ++i) + { + w = (word) c->constants.data[i]; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c5label); + } + + // If the class is an array, then the methods field holds a + // pointer to the element class. If the class is primitive, + // then the methods field holds a pointer to the array class. + w = (word) c->methods; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c6label); + + if (! c->isArray() && ! c->isPrimitive()) + { + // Scan each method in the cases where `methods' really + // points to a methods structure. + for (int i = 0; i < c->method_count; ++i) + { + w = (word) c->methods[i].name; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, + cm1label); + w = (word) c->methods[i].signature; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, + cm2label); + // FIXME: `ncode' entry? + } + } + + // Mark all the fields. + w = (word) c->fields; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8label); + for (int i = 0; i < c->field_count; ++i) + { +#ifndef COMPACT_FIELDS + w = (word) c->fields[i].name; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8alabel); +#endif + w = (word) c->fields[i].type; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8blabel); + } + + w = (word) c->vtable; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c9label); + w = (word) c->interfaces; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cAlabel); + for (int i = 0; i < c->interface_count; ++i) + { + w = (word) c->interfaces[i]; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cClabel); + } + w = (word) c->loader; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cBlabel); + } + else + { + // NOTE: each class only holds information about the class + // itself. So we must do the marking for the entire inheritance + // tree in order to mark all fields. FIXME: what about + // interfaces? We skip Object here, because Object only has a + // sync_info, and we handled that earlier. + // Note: occasionally `klass' can be null. For instance, this + // can happen if a GC occurs between the point where an object + // is allocated and where the vtbl slot is set. + while (klass && klass != &ObjectClass) + { + jfieldID field = JvGetFirstInstanceField (klass); + jint max = JvNumInstanceFields (klass); + + for (int i = 0; i < max; ++i) + { + if (JvFieldIsRef (field)) + { + jobject val = JvGetObjectField (obj, field); + w = (word) val; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, + obj, elabel); + } + field = field->getNextInstanceField (); + } + klass = klass->getSuperclass(); + } + } + + return mark_stack_ptr; +} + +// This is called by the GC during the mark phase. It marks a Java +// array (of objects). We use `void *' arguments and return, and not +// what the Boehm GC wants, to avoid pollution in our headers. +void * +_Jv_MarkArray (void *addr, void *msp, void *msl, void * /*env*/) +{ + mse *mark_stack_ptr = (mse *) msp; + mse *mark_stack_limit = (mse *) msl; + jobjectArray array = (jobjectArray) addr; + + _Jv_VTable *dt = *(_Jv_VTable **) addr; + // We check this in case a GC occurs before the vtbl is set. FIXME: + // should use allocation lock while initializing object. + if (! dt) + return mark_stack_ptr; + jclass klass = dt->clas; + + // Every object has a sync_info pointer. + word w = (word) array->sync_info; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, array, e1label); + // Mark the object's class. + w = (word) klass; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, obj, o2label); + + for (int i = 0; i < JvGetArrayLength (array); ++i) + { + jobject obj = elements (array)[i]; + w = (word) obj; + MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, array, e2label); + } + + return mark_stack_ptr; +} + +// Allocate space for a new Java object. FIXME: this might be the +// wrong interface; we might prefer to pass in the object type as +// well. It isn't important for this collector, but it might be for +// other collectors. +void * +_Jv_AllocObj (jsize size) +{ + return GC_GENERIC_MALLOC (size, obj_kind_x); +} + +// Allocate space for a new Java array. FIXME: again, this might be +// the wrong interface. +void * +_Jv_AllocArray (jsize size) +{ + return GC_GENERIC_MALLOC (size, array_kind_x); +} + +// Allocate some space that is known to be pointer-free. +void * +_Jv_AllocBytes (jsize size) +{ + return GC_GENERIC_MALLOC (size, PTRFREE); +} + +static void +call_finalizer (GC_PTR obj, GC_PTR client_data) +{ + _Jv_FinalizerFunc *fn = (_Jv_FinalizerFunc *) client_data; + jobject jobj = (jobject) obj; + + (*fn) (jobj); +} + +void +_Jv_RegisterFinalizer (void *object, _Jv_FinalizerFunc *meth) +{ + GC_REGISTER_FINALIZER_NO_ORDER (object, call_finalizer, meth, + NULL, NULL); +} + +void +_Jv_RunFinalizers (void) +{ + GC_invoke_finalizers (); +} + +void +_Jv_RunAllFinalizers (void) +{ + GC_finalize_all (); +} + +void +_Jv_RunGC (void) +{ + GC_gcollect (); +} + +long +_Jv_GCTotalMemory (void) +{ + return GC_get_heap_size (); +} + +/* Sum size of each hblk. */ +static void +sum_blocks (struct hblk *h, word arg) +{ + long *sump = (long *) arg; + /* This evil computation is from boehm-gc/checksums.c. */ + hdr *hhdr = HDR (h); + int bytes = WORDS_TO_BYTES (hhdr->hb_sz); + bytes += HDR_BYTES + HBLKSIZE - 1; + bytes &= ~ (HBLKSIZE - 1); + *sump += bytes; +} + +/* This turns out to be expensive to implement. For now, we don't + care. We could make it less expensive, perhaps, but that would + require some changes to the collector. */ +long +_Jv_GCFreeMemory (void) +{ + long sum = 0; + GC_apply_to_all_blocks (sum_blocks, &sum); + return sum; +} + +void +_Jv_InitGC (void) +{ + int proc; + DCL_LOCK_STATE; + + DISABLE_SIGNALS (); + LOCK (); + + if (initialized) + { + UNLOCK (); + ENABLE_SIGNALS (); + return; + } + initialized = 1; + + // Set up state for marking and allocation of Java objects. + obj_free_list = (ptr_t *) GC_generic_malloc_inner ((MAXOBJSZ + 1) + * sizeof (ptr_t), + PTRFREE); + memset (obj_free_list, 0, (MAXOBJSZ + 1) * sizeof (ptr_t)); + + proc = GC_n_mark_procs++; + GC_mark_procs[proc] = (mark_proc) _Jv_MarkObj; + + obj_kind_x = GC_n_kinds++; + GC_obj_kinds[obj_kind_x].ok_freelist = obj_free_list; + GC_obj_kinds[obj_kind_x].ok_reclaim_list = 0; + GC_obj_kinds[obj_kind_x].ok_descriptor = MAKE_PROC (proc, 0); + GC_obj_kinds[obj_kind_x].ok_relocate_descr = FALSE; + GC_obj_kinds[obj_kind_x].ok_init = TRUE; + + // Set up state for marking and allocation of arrays of Java + // objects. + array_free_list = (ptr_t *) GC_generic_malloc_inner ((MAXOBJSZ + 1) + * sizeof (ptr_t), + PTRFREE); + memset (array_free_list, 0, (MAXOBJSZ + 1) * sizeof (ptr_t)); + + proc = GC_n_mark_procs++; + GC_mark_procs[proc] = (mark_proc) _Jv_MarkArray; + + array_kind_x = GC_n_kinds++; + GC_obj_kinds[array_kind_x].ok_freelist = array_free_list; + GC_obj_kinds[array_kind_x].ok_reclaim_list = 0; + GC_obj_kinds[array_kind_x].ok_descriptor = MAKE_PROC (proc, 0); + GC_obj_kinds[array_kind_x].ok_relocate_descr = FALSE; + GC_obj_kinds[array_kind_x].ok_init = TRUE; + + UNLOCK (); + ENABLE_SIGNALS (); +} diff --git a/libjava/chartables.pl b/libjava/chartables.pl new file mode 100644 index 00000000000..fbcfb277d7b --- /dev/null +++ b/libjava/chartables.pl @@ -0,0 +1,965 @@ +# chartables.pl - A perl program to generate tables for use by the +# Character class. + +# Copyright (C) 1998, 1999 Cygnus Solutions +# +# This file is part of libjava. +# +# This software is copyrighted work licensed under the terms of the +# Libjava License. Please consult the file "LIBJAVA_LICENSE" for +# details. + +# This program requires a `unidata.txt' file of the form distributed +# on the Unicode 2.0 CD ROM. Or, get it more conveniently here: +# ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData-Latest.txt +# Version `2.1.8' of this file was last used to update the Character class. + +# Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 +# "The Java Language Specification", ISBN 0-201-63451-1 +# plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + +# Usage: perl chartables.pl [-n] UnicodeData-VERSION.txt +# If this exits with nonzero status, then you must investigate the +# cause of the problem. +# Diagnostics and other information to stderr. +# This creates the new include/java-chartables.h and +# include/java-chardecomp.h files directly. +# With -n, the files are not created, but all processing +# still occurs. + +# Fields in the table. +$CODE = 0; +$NAME = 1; +$CATEGORY = 2; +$DECOMPOSITION = 5; +$DECIMAL = 6; +$DIGIT = 7; +$NUMERIC = 8; +$UPPERCASE = 12; +$LOWERCASE = 13; +$TITLECASE = 14; + +# A special case. +$TAMIL_DIGIT_ONE = 0x0be7; +$TAMIL_DIGIT_NINE = 0x0bef; + +# These are endpoints of legitimate gaps in the tables. +$CJK_IDEOGRAPH_END = 0x9fa5; +$HANGUL_END = 0xd7a3; +$HIGH_SURROGATE_END = 0xdb7f; +$PRIVATE_HIGH_SURROGATE_END = 0xdbff; +$LOW_SURROGATE_END = 0xdfff; +$PRIVATE_END = 0xf8ff; + +%title_to_upper = (); +%title_to_lower = (); +%numerics = (); +%name = (); + +@digit_start = (); +@digit_end = (); + +@space_start = (); +@space_end = (); + +# @letter_start = (); +# @letter_end = (); + +@all_start = (); +@all_end = (); +@all_cats = (); + +@upper_start = (); +@upper_end = (); +@upper_map = (); +%upper_anom = (); + +@lower_start = (); +@lower_end = (); +@lower_map = (); +%lower_anom = (); + +@attributes = (); + +# There are a few characters which actually need two attributes. +# These are special-cased. +$ROMAN_START = 0x2160; +$ROMAN_END = 0x217f; +%second_attributes = (); + +$prevcode = -1; +$status = 0; + +%category_map = +( + 'Mn' => 'NON_SPACING_MARK', + 'Mc' => 'COMBINING_SPACING_MARK', + 'Me' => 'ENCLOSING_MARK', + 'Nd' => 'DECIMAL_DIGIT_NUMBER', + 'Nl' => 'LETTER_NUMBER', + 'No' => 'OTHER_NUMBER', + 'Zs' => 'SPACE_SEPARATOR', + 'Zl' => 'LINE_SEPARATOR', + 'Zp' => 'PARAGRAPH_SEPARATOR', + 'Cc' => 'CONTROL', + 'Cf' => 'FORMAT', + 'Cs' => 'SURROGATE', + 'Co' => 'PRIVATE_USE', + 'Cn' => 'UNASSIGNED', + 'Lu' => 'UPPERCASE_LETTER', + 'Ll' => 'LOWERCASE_LETTER', + 'Lt' => 'TITLECASE_LETTER', + 'Lm' => 'MODIFIER_LETTER', + 'Lo' => 'OTHER_LETTER', + 'Pc' => 'CONNECTOR_PUNCTUATION', + 'Pd' => 'DASH_PUNCTUATION', + 'Ps' => 'START_PUNCTUATION', + 'Pe' => 'END_PUNCTUATION', + 'Pi' => 'START_PUNCTUATION', + 'Pf' => 'END_PUNCTUATION', + 'Po' => 'OTHER_PUNCTUATION', + 'Sm' => 'MATH_SYMBOL', + 'Sc' => 'CURRENCY_SYMBOL', + 'Sk' => 'MODIFIER_SYMBOL', + 'So' => 'OTHER_SYMBOL' + ); + +# These maps characters to their decompositions. +%canonical_decomposition = (); +%full_decomposition = (); + + +# Handle `-n' and open output files. +local ($f1, $f2) = ('include/java-chartables.h', + 'include/java-chardecomp.h'); +if ($ARGV[0] eq '-n') +{ + shift @ARGV; + $f1 = '/dev/null'; + $f2 = '/dev/null'; +} + +open (CHARTABLE, "> $f1"); +open (DECOMP, "> $f2"); + +# Process the Unicode file. +while (<>) +{ + chop; + # Specify a limit for split so that we pick up trailing fields. + # We make the limit larger than we need, to catch the case where + # there are extra fields. + @fields = split (';', $_, 30); + # Convert code to number. + $ncode = hex ($fields[$CODE]); + + if ($#fields != 14) + { + print STDERR ("Entry for \\u", $fields[$CODE], + " has wrong number of fields: ", $#fields, "\n"); + } + + $name{$fields[$CODE]} = $fields[$NAME]; + + # If we've found a gap in the table, fill it in. + if ($ncode != $prevcode + 1) + { + &process_gap (*fields, $prevcode, $ncode); + } + + &process_char (*fields, $ncode); + + $prevcode = $ncode; +} + +if ($prevcode != 0xffff) +{ + # Setting of `fields' parameter doesn't matter here. + &process_gap (*fields, $prevcode, 0x10000); +} + +print CHARTABLE "// java-chartables.h - Character tables for java.lang.Character -*- c++ -*-\n\n"; +print CHARTABLE "#ifndef __JAVA_CHARTABLES_H__\n"; +print CHARTABLE "#define __JAVA_CHARTABLES_H__\n\n"; +print CHARTABLE "// These tables are automatically generated by the chartables.pl\n"; +print CHARTABLE "// script. DO NOT EDIT the tables. Instead, fix the script\n"; +print CHARTABLE "// and run it again.\n\n"; +print CHARTABLE "// This file should only be included by natCharacter.cc\n\n"; + + +$bytes = 0; + +# Titlecase mapping tables. +if ($#title_to_lower != $#title_to_upper) +{ + # If this fails we need to reimplement toTitleCase. + print STDERR "titlecase mappings have different sizes\n"; + $status = 1; +} +# Also ensure that the tables are entirely parallel. +foreach $key (sort keys %title_to_lower) +{ + if (! defined $title_to_upper{$key}) + { + print STDERR "titlecase mappings have different entries\n"; + $status = 1; + } +} +&print_single_map ("title_to_lower_table", %title_to_lower); +&print_single_map ("title_to_upper_table", %title_to_upper); + +print CHARTABLE "#ifdef COMPACT_CHARACTER\n\n"; + +printf CHARTABLE "#define TAMIL_DIGIT_ONE 0x%04x\n\n", $TAMIL_DIGIT_ONE; + +# All numeric values. +&print_numerics; + +# Digits only. +&print_block ("digit_table", *digit_start, *digit_end); + +# Space characters. +&print_block ("space_table", *space_start, *space_end); + +# Letters. We used to generate a separate letter table. But this +# doesn't really seem worthwhile. Simply using `all_table' saves us +# about 800 bytes, and only adds 3 table probes to isLetter. +# &print_block ("letter_table", *letter_start, *letter_end); + +# Case tables. +&print_case_table ("upper", *upper_start, *upper_end, *upper_map, *upper_anom); +&print_case_table ("lower", *lower_start, *lower_end, *lower_map, *lower_anom); + +# Everything else. +&print_all_block (*all_start, *all_end, *all_cats); + +print CHARTABLE "#else /* COMPACT_CHARACTER */\n\n"; + +printf CHARTABLE "#define ROMAN_START 0x%04x\n", $ROMAN_START; +printf CHARTABLE "#define ROMAN_END 0x%04x\n\n", $ROMAN_END; + +&print_fast_tables (*all_start, *all_end, *all_cats, + *attributes, *second_attributes); + +print CHARTABLE "#endif /* COMPACT_CHARACTER */\n\n"; + +print CHARTABLE "#endif /* __JAVA_CHARTABLES_H__ */\n"; + +printf STDERR "Approximately %d bytes of data generated (compact case)\n", + $bytes; + + +# Now generate decomposition tables. +printf DECOMP "// java-chardecomp.h - Decomposition character tables -*- c++ -*-\n\n"; +printf DECOMP "#ifndef __JAVA_CHARDECOMP_H__\n"; +printf DECOMP "#define __JAVA_CHARDECOMP_H__\n\n"; +print DECOMP "// These tables are automatically generated by the chartables.pl\n"; +print DECOMP "// script. DO NOT EDIT the tables. Instead, fix the script\n"; +print DECOMP "// and run it again.\n\n"; +print DECOMP "// This file should only be included by natCollator.cc\n\n"; + +print DECOMP "struct decomp_entry\n{\n"; +print DECOMP " jchar key;\n"; +print DECOMP " const char *value;\n"; +print DECOMP "};\n\n"; + +&write_decompositions; + +printf DECOMP "#endif /* __JAVA_CHARDECOMP_H__ */\n"; + + +close (CHARTABLE); +close (DECOMP); + +exit $status; + + +# Process a gap in the space. +sub process_gap +{ + local (*fields, $prevcode, $ncode) = @_; + local (@gap_fields, $i); + + if ($ncode == $CJK_IDEOGRAPH_END + || $ncode == $HANGUL_END + || $ncode == $HIGH_SURROGATE_END + || $ncode == $PRIVATE_HIGH_SURROGATE_END + || $ncode == $LOW_SURROGATE_END + || $ncode == $PRIVATE_END) + { + # The characters in the gap we just found are known to + # have the same properties as the character at the end of + # the gap. + @gap_fields = @fields; + } + else + { + # This prints too much to be enabled. + # print STDERR "Gap found at \\u", $fields[$CODE], "\n"; + @gap_fields = ('', '', 'Cn', '', '', '', '', '', '', '', '', + '', '', '', ''); + } + + for ($i = $prevcode + 1; $i < $ncode; ++$i) + { + $gap_fields[$CODE] = sprintf ("%04x", $i); + $gap_fields[$NAME] = "CHARACTER " . $gap_fields[$CODE]; + &process_char (*gap_fields, $i); + } +} + +# Process a single character. +sub process_char +{ + local (*fields, $ncode) = @_; + + if ($fields[$DECOMPOSITION] ne '') + { + &add_decomposition ($ncode, $fields[$DECOMPOSITION]); + } + + # If this is a titlecase character, mark it. + if ($fields[$CATEGORY] eq 'Lt') + { + $title_to_upper{$fields[$CODE]} = $fields[$UPPERCASE]; + $title_to_lower{$fields[$CODE]} = $fields[$LOWERCASE]; + } + else + { + # For upper and lower case mappings, we try to build compact + # tables that map range onto range. We specifically want to + # avoid titlecase characters. Java specifies a range check to + # make sure the character is not between 0x2000 and 0x2fff. + # We avoid that here because we need to generate table entries + # -- toLower and toUpper still work in that range. + if ($fields[$UPPERCASE] eq '' + && ($fields[$LOWERCASE] ne '' + || $fields[$NAME] =~ /CAPITAL (LETTER|LIGATURE)/)) + { + if ($fields[$LOWERCASE] ne '') + { + &update_case_block (*upper_start, *upper_end, *upper_map, + $fields[$CODE], $fields[$LOWERCASE]); + &set_attribute ($ncode, hex ($fields[$LOWERCASE])); + } + else + { + $upper_anom{$fields[$CODE]} = 1; + } + } + elsif ($fields[$LOWERCASE] ne '') + { + print STDERR ("Java missed upper case char \\u", + $fields[$CODE], "\n"); + } + elsif ($fields[$CATEGORY] eq 'Lu') + { + # This case is for letters which are marked as upper case + # but for which there is no lower case equivalent. For + # instance, LATIN LETTER YR. + } + + if ($fields[$LOWERCASE] eq '' + && ($fields[$UPPERCASE] ne '' + || $fields[$NAME] =~ /SMALL (LETTER|LIGATURE)/)) + { + if ($fields[$UPPERCASE] ne '') + { + &update_case_block (*lower_start, *lower_end, *lower_map, + $fields[$CODE], $fields[$UPPERCASE]); + &set_attribute ($ncode, hex ($fields[$UPPERCASE])); + } + else + { + $lower_anom{$fields[$CODE]} = 1; + } + } + elsif ($fields[$UPPERCASE] ne '') + { + print STDERR ("Java missed lower case char \\u", + $fields[$CODE], "\n"); + } + elsif ($fields[$CATEGORY] eq 'Ll') + { + # This case is for letters which are marked as lower case + # but for which there is no upper case equivalent. For + # instance, FEMININE ORDINAL INDICATOR. + } + } + + + # If we have a non-decimal numeric value, add it to the list. + if ($fields[$CATEGORY] eq 'Nd' + && ($ncode < 0x2000 || $ncode > 0x2fff) + && $fields[$NAME] =~ /DIGIT/) + { + # This is a digit character that is handled elsewhere. + } + elsif ($fields[$DIGIT] ne '' || $fields[$NUMERIC] ne '') + { + # Do a simple check. + if ($fields[$DECIMAL] ne '') + { + # This catches bugs in an earlier implementation of + # chartables.pl. Now it is here for historical interest + # only. + # print STDERR ("Character \u", $fields[$CODE], + # " would have been missed as digit\n"); + } + + local ($val) = $fields[$DIGIT]; + $val = $fields[$NUMERIC] if $val eq ''; + local ($ok) = 1; + + # If we have a value which is not a positive integer, then we + # set the value to -2 to make life easier for + # Character.getNumericValue. + if ($val !~ m/^[0-9]+$/) + { + if ($fields[$CATEGORY] ne 'Nl' + && $fields[$CATEGORY] ne 'No') + { + # This shows a few errors in the Unicode table. These + # characters have a missing Numeric field, and the `N' + # for the mirrored field shows up there instead. I + # reported these characters to errata@unicode.org on + # Thu Sep 10 1998. They said it will be fixed in the + # 2.1.6 release of the tables. + print STDERR ("Character \u", $fields[$CODE], + " has value but is not numeric; val = '", + $val, "'\n"); + # We skip these. + $ok = 0; + } + $val = "-2"; + } + + if ($ok) + { + $numerics{$fields[$CODE]} = $val; + &set_attribute ($ncode, $val); + } + } + + # We build a table that lists ranges of ordinary decimal values. + # At each step we make sure that the digits are in the correct + # order, with no holes, as this is assumed by Character. If this + # fails, reimplementation is required. This implementation + # dovetails nicely with the Java Spec, which has strange rules for + # what constitutes a decimal value. In particular the Unicode + # name must contain the word `DIGIT'. The spec doesn't directly + # say that digits must have type `Nd' (or that their value must an + # integer), but that can be inferred from the list of digits in + # the book(s). Currently the only Unicode characters whose name + # includes `DIGIT' which would not fit are the Tibetan "half" + # digits. + if ($fields[$CATEGORY] eq 'Nd') + { + if (($ncode < 0x2000 || $ncode > 0x2fff) + && $fields[$NAME] =~ /DIGIT/) + { + &update_digit_block (*digit_start, *digit_end, $fields[$CODE], + $fields[$DECIMAL]); + &set_attribute ($ncode, $fields[$DECIMAL]); + } + else + { + # If this fails then Character.getType will fail. We + # assume that things in `digit_table' are the only + # category `Nd' characters. + print STDERR ("Character \u", $fields[$CODE], + " is class Nd but not in digit table\n"); + $status = 1; + } + } + + # Keep track of space characters. + if ($fields[$CATEGORY] =~ /Z[slp]/) + { + &update_block (*space_start, *space_end, $fields[$CODE]); + } + + # Keep track of letters. + # if ($fields[$CATEGORY] =~ /L[ultmo]/) + # { + # &update_letter_block (*letter_start, *letter_end, $fields[$CODE], + # $fields[$CATEGORY]); + # } + + # Keep track of all characters. You might think we wouldn't have + # to do this for uppercase letters, or other characters we already + # "classify". The problem is that this classification is + # different. E.g., \u216f is uppercase by Java rules, but is a + # LETTER_NUMBER here. + &update_all_block (*all_start, *all_end, *all_cats, + $fields[$CODE], $fields[$CATEGORY]); +} + + +# Called to add a new decomposition. +sub add_decomposition +{ + local ($ncode, $value) = @_; + local ($is_full) = 0; + local ($first) = 1; + local (@decomp) = (); + + foreach (split (' ', $value)) + { + if ($first && /^\<.*\>$/) + { + $is_full = 1; + } + else + { + push (@decomp, hex ($_)); + } + $first = 0; + } + + # We pack the value into a string because this means we can stick + # with Perl 4 features. + local ($s) = pack "I*", @decomp; + if ($is_full) + { + $full_decomposition{$ncode} = $s; + } + else + { + $canonical_decomposition{$ncode} = $s; + } +} + +# Write a single decomposition table. +sub write_single_decomposition +{ + local ($name, $is_canon, %table) = @_; + + printf DECOMP "static const decomp_entry ${name}_decomposition[] =\n{\n"; + + local ($key, @expansion, $char); + local ($first_line) = 1; + + for ($key = 0; $key <= 65535; ++$key) + { + next if ! defined $table{$key}; + + printf DECOMP ",\n" + unless $first_line; + $first_line = 0; + + printf DECOMP " { 0x%04x, \"", $key; + + # We represent the expansion as a series of bytes, terminated + # with a double nul. This is ugly, but relatively + # space-efficient. Most expansions are short, but there are a + # few that are very long (e.g. \uFDFA). This means that if we + # chose a fixed-space representation we would waste a lot of + # space. + @expansion = unpack "I*", $table{$key}; + foreach $char (@expansion) + { + printf DECOMP "\\x%02x\\x%02x", ($char / 256), ($char % 256); + } + + printf DECOMP "\" }"; + } + + printf DECOMP "\n};\n\n"; +} + +sub write_decompositions +{ + &write_single_decomposition ('canonical', 1, %canonical_decomposition); + &write_single_decomposition ('full', 0, %full_decomposition); +} + +# We represent a block of characters with a pair of lists. This +# function updates the pair to account for the new character. Returns +# 1 if we added to the old block, 0 otherwise. +sub update_block +{ + local (*start, *end, $char) = @_; + + local ($nchar) = hex ($char); + local ($count) = $#end; + if ($count >= 0 && $end[$count] == $nchar - 1) + { + ++$end[$count]; + return 1; + } + else + { + ++$count; + $start[$count] = $nchar; + $end[$count] = $nchar; + } + return 0; +} + +# Return true if we will be appending this character to the end of the +# existing block. +sub block_append_p +{ + local (*end, $char) = @_; + return $#end >= 0 && $end[$#end] == $char - 1; +} + +# This updates the digit block. This table is much like an ordinary +# block, but it has an extra constraint. +sub update_digit_block +{ + local (*start, *end, $char, $value) = @_; + + &update_block ($start, $end, $char); + local ($nchar) = hex ($char); + + # We want to make sure that the new digit's value is correct for + # its place in the block. However, we special-case Tamil digits, + # since Tamil does not have a digit `0'. + local ($count) = $#start; + if (($nchar < $TAMIL_DIGIT_ONE || $nchar > $TAMIL_DIGIT_NINE) + && $nchar - $start[$count] != $value) + { + # If this fails then Character.digit_value will be wrong. + print STDERR "Character \\u", $char, " violates digit constraint\n"; + $status = 1; + } +} + +# Update letter table. We could be smart about avoiding upper or +# lower case letters, but it is much simpler to just track them all. +sub update_letter_block +{ + local (*start, *end, $char, $category) = @_; + + &update_block (*start, *end, $char); +} + +# Update `all' table. This table holds all the characters we don't +# already categorize for other reasons. FIXME: if a given type has +# very few characters, we should just inline the code. E.g., there is +# only one paragraph separator. +sub update_all_block +{ + local (*start, *end, *cats, $char, $category) = @_; + + local ($nchar) = hex ($char); + local ($count) = $#end; + if ($count >= 0 + && $end[$count] == $nchar - 1 + && $cats[$count] eq $category) + { + ++$end[$count]; + } + else + { + ++$count; + $start[$count] = $nchar; + $end[$count] = $nchar; + $cats[$count] = $category; + } +} + +# Update a case table. We handle case tables specially because we +# want to map (e.g.) a block of uppercase characters directly onto the +# corresponding block of lowercase characters. Therefore we generate +# a new entry when the block would no longer map directly. +sub update_case_block +{ + local (*start, *end, *map, $char, $mapchar) = @_; + + local ($nchar) = hex ($char); + local ($nmap) = hex ($mapchar); + + local ($count) = $#end; + if ($count >= 0 + && $end[$count] == $nchar - 1 + && $nchar - $start[$count] == $nmap - $map[$count]) + { + ++$end[$count]; + } + else + { + ++$count; + $start[$count] = $nchar; + $end[$count] = $nchar; + $map[$count] = $nmap; + } +} + +# Set the attribute value for the character. Each character can have +# only one attribute. +sub set_attribute +{ + local ($ncode, $attr) = @_; + + if ($attributes{$ncode} ne '' && $attributes{$ncode} ne $attr) + { + if ($ncode >= $ROMAN_START && $ncode <= $ROMAN_END) + { + $second_attributes{$ncode} = $attr; + } + else + { + printf STDERR "character \\u%04x already has attribute\n", $ncode; + } + } + # Attributes can be interpreted as unsigned in some situations, + # so we check against 65535. This could cause errors -- we need + # to check the interpretation here. + elsif ($attr < -32768 || $attr > 65535) + { + printf STDERR "attribute out of range for character \\u%04x\n", $ncode; + } + else + { + $attributes{$ncode} = $attr; + } +} + + +# Print a block table. +sub print_block +{ + local ($title, *start, *end) = @_; + + print CHARTABLE "static const jchar ", $title, "[][2] =\n"; + print CHARTABLE " {\n"; + + local ($i) = 0; + while ($i <= $#start) + { + print CHARTABLE " { "; + &print_char ($start[$i]); + print CHARTABLE ", "; + &print_char ($end[$i]); + print CHARTABLE " }"; + print CHARTABLE "," if ($i != $#start); + print CHARTABLE "\n"; + ++$i; + $bytes += 4; # Two bytes per char. + } + + print CHARTABLE " };\n\n"; +} + +# Print the numerics table. +sub print_numerics +{ + local ($i, $key, $count, @keys); + + $i = 0; + @keys = sort keys %numerics; + $count = @keys; + + print CHARTABLE "static const jchar numeric_table[] =\n"; + print CHARTABLE " { "; + foreach $key (@keys) + { + &print_char (hex ($key)); + ++$i; + print CHARTABLE ", " if $i < $count; + # Print 5 per line. + print CHARTABLE "\n " if ($i % 5 == 0); + $bytes += 2; # One character. + } + print CHARTABLE " };\n\n"; + + print CHARTABLE "static const jshort numeric_value[] =\n"; + print CHARTABLE " { "; + $i = 0; + foreach $key (@keys) + { + print CHARTABLE $numerics{$key}; + if ($numerics{$key} > 32767 || $numerics{$key} < -32768) + { + # This means our generated type info is incorrect. We + # could just detect and work around this here, but I'm + # lazy. + print STDERR "numeric value won't fit in a short\n"; + $status = 1; + } + ++$i; + print CHARTABLE ", " if $i < $count; + # Print 10 per line. + print CHARTABLE "\n " if ($i % 10 == 0); + $bytes += 2; # One short. + } + print CHARTABLE " };\n\n"; +} + +# Print a table that maps one single letter onto another. It assumes +# the map is index by char code. +sub print_single_map +{ + local ($title, %map) = @_; + + local (@keys) = sort keys %map; + $num = @keys; + print CHARTABLE "static const jchar ", $title, "[][2] =\n"; + print CHARTABLE " {\n"; + $i = 0; + for $key (@keys) + { + print CHARTABLE " { "; + &print_char (hex ($key)); + print CHARTABLE ", "; + &print_char (hex ($map{$key})); + print CHARTABLE " }"; + ++$i; + if ($i < $num) + { + print CHARTABLE ","; + } + else + { + print CHARTABLE " "; + } + print CHARTABLE " // ", $name{$key}, "\n"; + $bytes += 4; # Two bytes per char. + } + print CHARTABLE " };\n\n"; +} + +# Print the `all' block. +sub print_all_block +{ + local (*start, *end, *cats) = @_; + + &print_block ("all_table", *start, *end); + + local ($i) = 0; + local ($sum) = 0; + while ($i <= $#start) + { + $sum += $end[$i] - $start[$i] + 1; + ++$i; + } + # We do this computation just to make sure it isn't cheaper to + # simply list all the characters individually. + printf STDERR ("all_table encodes %d characters in %d entries\n", + $sum, $#start + 1); + + print CHARTABLE "static const jbyte category_table[] =\n"; + print CHARTABLE " { "; + + $i = 0; + while ($i <= $#cats) + { + if ($i > 0 && $cats[$i] eq $cats[$i - 1]) + { + # This isn't an error. We can have a duplicate because + # two ranges are not adjacent while the intervening + # characters are left out of the table for other reasons. + # We could exploit this to make the table a little smaller. + # printf STDERR "Duplicate all entry at \\u%04x\n", $start[$i]; + } + print CHARTABLE 'java::lang::Character::', $category_map{$cats[$i]}; + print CHARTABLE ", " if ($i < $#cats); + ++$i; + print CHARTABLE "\n "; + ++$bytes; + } + print CHARTABLE " };\n\n"; +} + +# Print case table. +sub print_case_table +{ + local ($title, *start, *end, *map, *anomalous) = @_; + + &print_block ($title . '_case_table', *start, *end); + + print CHARTABLE "static const jchar ", $title, "_case_map_table[] =\n"; + print CHARTABLE " { "; + + local ($i) = 0; + while ($i <= $#map) + { + &print_char ($map[$i]); + print CHARTABLE ", " if $i < $#map; + ++$i; + print CHARTABLE "\n " if $i % 5 == 0; + $bytes += 2; + } + print CHARTABLE " };\n"; + + + local ($key, @keys); + @keys = sort keys %anomalous; + + if ($title eq 'upper') + { + if ($#keys >= 0) + { + # If these are found we need to change Character.isUpperCase. + print STDERR "Found anomalous upper case characters\n"; + $status = 1; + } + } + else + { + print CHARTABLE "\n"; + print CHARTABLE "static const jchar ", $title, "_anomalous_table[] =\n"; + print CHARTABLE " { "; + $i = 0; + foreach $key (@keys) + { + &print_char (hex ($key)); + print CHARTABLE ", " if $i < $#keys; + ++$i; + print CHARTABLE "\n " if $i % 5 == 0; + $bytes += 2; + } + print CHARTABLE " };\n"; + } + + print CHARTABLE "\n"; +} + +# Print the type table and attributes table for the fast version. +sub print_fast_tables +{ + local (*start, *end, *cats, *atts, *second_atts) = @_; + + print CHARTABLE "static const jbyte type_table[] =\n{ "; + + local ($i, $j); + for ($i = 0; $i <= $#cats; ++$i) + { + for ($j = $start[$i]; $j <= $end[$i]; ++$j) + { + print CHARTABLE 'java::lang::Character::', $category_map{$cats[$i]}; + print CHARTABLE "," if ($i < $#cats || $j < $end[$i]); + print CHARTABLE "\n "; + } + } + print CHARTABLE "\n };\n\n"; + + print CHARTABLE "static const jshort attribute_table[] =\n{ "; + for ($i = 0; $i <= 0xffff; ++$i) + { + $atts{$i} = 0 if ! defined $atts{$i}; + print CHARTABLE $atts{$i}; + print CHARTABLE ", " if $i < 0xffff; + print CHARTABLE "\n " if $i % 5 == 1; + } + print CHARTABLE "\n };\n\n"; + + print CHARTABLE "static const jshort secondary_attribute_table[] =\n{ "; + for ($i = $ROMAN_START; $i <= $ROMAN_END; ++$i) + { + print CHARTABLE $second_atts{$i}; + print CHARTABLE ", " if $i < $ROMAN_END; + print CHARTABLE "\n " if $i % 5 == 1; + } + print CHARTABLE "\n };\n\n"; +} + +# Print a character constant. +sub print_char +{ + local ($ncode) = @_; + printf CHARTABLE "0x%04x", $ncode; +} diff --git a/libjava/classes.pl b/libjava/classes.pl new file mode 100644 index 00000000000..4db80a08c2e --- /dev/null +++ b/libjava/classes.pl @@ -0,0 +1,104 @@ +# classes.pl - A perl program to generate most of the contents of +# javaprims.h automatically. + +# Copyright (C) 1998, 1999 Cygnus Solutions +# +# This file is part of libjava. +# +# This software is copyrighted work licensed under the terms of the +# Libjava License. Please consult the file "LIBJAVA_LICENSE" for +# details. + +# Usage: cd ; perl classes.pl. +# Can also be run from the `include' directory; this lets us +# more easily insert the output into javaprims.h (which is where it goes). + +use DirHandle; + +if (-d 'java') +{ + # Ok here. +} +elsif (-d '../java') +{ + chdir ('..'); +} +else +{ + die "couldn't find java directory\n"; +} + +&scan ('java', 2); + +exit 0; + +sub scan +{ + local ($dir, $indent) = @_; + local (@subdirs) = (); + local (@classes) = (); + + local ($d) = new DirHandle $dir; + local (*JFILE); + local ($name); + if (defined $d) + { + while (defined ($name = $d->read)) + { + next if $name eq 'CVS'; + next if $name eq '.'; + next if $name eq '..'; + if ($dir eq 'java' + && $name ne 'lang' + && $name ne 'util' + && $name ne 'io') + { + # We only generate decls for java.lang, java.io, and + # java.util. + next; + } + if (-d ($dir . '/' . $name)) + { + push (@subdirs, $name); + next; + } + next unless $name =~ /\.java$/; + + open (FILE, "< $dir/$name"); + while () + { + # NOTE: we don't skip `/*' comments. + s,//.*$,,; + # For now assume that class names start with upper + # case letter. + next unless /(class|interface) ([A-Z][A-Za-z0-9]+)/; + push (@classes, $2); + } + close (FILE); + } + + undef $d; + } + + local ($spaces) = ' ' x $indent; + local ($classname); + ($classname = $dir) =~ s/^.*\///; + print $spaces, "namespace ", $classname, "\n"; + print $spaces, "{\n"; + + foreach (sort @classes) + { + print $spaces, " class ", $_, ";\n"; + } + print "\n" if scalar @classes > 0 && scalar @subdirs > 0; + + local ($first) = 1; + foreach (sort @subdirs) + { + print "\n" unless $first; + $first = 0; + &scan ("$dir/$_", $indent + 2); + } + + print $spaces, "};\n"; +} diff --git a/libjava/configure b/libjava/configure new file mode 100755 index 00000000000..84067083648 --- /dev/null +++ b/libjava/configure @@ -0,0 +1,3783 @@ +#! /bin/sh + +# Guess values for system-dependent variables and create Makefiles. +# Generated automatically using autoconf version 2.13 +# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc. +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. + +# Defaults: +ac_help= +ac_default_prefix=/usr/local +# Any additions from configure.in: +ac_help="$ac_help + --with-target-subdir=SUBDIR Configuring in a subdirectory" +ac_help="$ac_help + --with-cross-host=HOST Configuring with a cross compiler" +ac_help="$ac_help + --enable-multilib build many library versions (default)" +ac_help="$ac_help + --enable-maintainer-mode enable make rules and dependencies not useful + (and sometimes confusing) to the casual installer" +ac_help="$ac_help + --enable-fast-character Prefer speed over size for Character" +ac_help="$ac_help + --enable-libgcj-debug Enable runtime debugging code" +ac_help="$ac_help + --with-ecos Enable runtime eCos target support." +ac_help="$ac_help + --enable-java-gc=TYPE choose garbage collector [boehm]" +ac_help="$ac_help + --enable-threads=TYPE choose threading package" + +# Initialize some variables set by options. +# The variables have the same names as the options, with +# dashes changed to underlines. +build=NONE +cache_file=./config.cache +exec_prefix=NONE +host=NONE +no_create= +nonopt=NONE +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +target=NONE +verbose= +x_includes=NONE +x_libraries=NONE +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datadir='${prefix}/share' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +libdir='${exec_prefix}/lib' +includedir='${prefix}/include' +oldincludedir='/usr/include' +infodir='${prefix}/info' +mandir='${prefix}/man' + +# Initialize some other variables. +subdirs= +MFLAGS= MAKEFLAGS= +SHELL=${CONFIG_SHELL-/bin/sh} +# Maximum number of lines to put in a shell here document. +ac_max_here_lines=12 + +ac_prev= +for ac_option +do + + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval "$ac_prev=\$ac_option" + ac_prev= + continue + fi + + case "$ac_option" in + -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;; + *) ac_optarg= ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case "$ac_option" in + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir="$ac_optarg" ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build="$ac_optarg" ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file="$ac_optarg" ;; + + -datadir | --datadir | --datadi | --datad | --data | --dat | --da) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \ + | --da=*) + datadir="$ac_optarg" ;; + + -disable-* | --disable-*) + ac_feature=`echo $ac_option|sed -e 's/-*disable-//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then + { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; } + fi + ac_feature=`echo $ac_feature| sed 's/-/_/g'` + eval "enable_${ac_feature}=no" ;; + + -enable-* | --enable-*) + ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then + { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; } + fi + ac_feature=`echo $ac_feature| sed 's/-/_/g'` + case "$ac_option" in + *=*) ;; + *) ac_optarg=yes ;; + esac + eval "enable_${ac_feature}='$ac_optarg'" ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix="$ac_optarg" ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he) + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat << EOF +Usage: configure [options] [host] +Options: [defaults in brackets after descriptions] +Configuration: + --cache-file=FILE cache test results in FILE + --help print this message + --no-create do not create output files + --quiet, --silent do not print \`checking...' messages + --version print the version of autoconf that created configure +Directory and file names: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [same as prefix] + --bindir=DIR user executables in DIR [EPREFIX/bin] + --sbindir=DIR system admin executables in DIR [EPREFIX/sbin] + --libexecdir=DIR program executables in DIR [EPREFIX/libexec] + --datadir=DIR read-only architecture-independent data in DIR + [PREFIX/share] + --sysconfdir=DIR read-only single-machine data in DIR [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data in DIR + [PREFIX/com] + --localstatedir=DIR modifiable single-machine data in DIR [PREFIX/var] + --libdir=DIR object code libraries in DIR [EPREFIX/lib] + --includedir=DIR C header files in DIR [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc in DIR [/usr/include] + --infodir=DIR info documentation in DIR [PREFIX/info] + --mandir=DIR man documentation in DIR [PREFIX/man] + --srcdir=DIR find the sources in DIR [configure dir or ..] + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM + run sed PROGRAM on installed program names +EOF + cat << EOF +Host type: + --build=BUILD configure for building on BUILD [BUILD=HOST] + --host=HOST configure for HOST [guessed] + --target=TARGET configure for TARGET [TARGET=HOST] +Features and packages: + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --x-includes=DIR X include files are in DIR + --x-libraries=DIR X library files are in DIR +EOF + if test -n "$ac_help"; then + echo "--enable and --with options recognized:$ac_help" + fi + exit 0 ;; + + -host | --host | --hos | --ho) + ac_prev=host ;; + -host=* | --host=* | --hos=* | --ho=*) + host="$ac_optarg" ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir="$ac_optarg" ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir="$ac_optarg" ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir="$ac_optarg" ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir="$ac_optarg" ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst \ + | --locals | --local | --loca | --loc | --lo) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* \ + | --locals=* | --local=* | --loca=* | --loc=* | --lo=*) + localstatedir="$ac_optarg" ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir="$ac_optarg" ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir="$ac_optarg" ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix="$ac_optarg" ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix="$ac_optarg" ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix="$ac_optarg" ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name="$ac_optarg" ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir="$ac_optarg" ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir="$ac_optarg" ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site="$ac_optarg" ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir="$ac_optarg" ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir="$ac_optarg" ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target="$ac_optarg" ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers) + echo "configure generated by autoconf version 2.13" + exit 0 ;; + + -with-* | --with-*) + ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then + { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } + fi + ac_package=`echo $ac_package| sed 's/-/_/g'` + case "$ac_option" in + *=*) ;; + *) ac_optarg=yes ;; + esac + eval "with_${ac_package}='$ac_optarg'" ;; + + -without-* | --without-*) + ac_package=`echo $ac_option|sed -e 's/-*without-//'` + # Reject names that are not valid shell variable names. + if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then + { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; } + fi + ac_package=`echo $ac_package| sed 's/-/_/g'` + eval "with_${ac_package}=no" ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes="$ac_optarg" ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries="$ac_optarg" ;; + + -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; } + ;; + + *) + if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then + echo "configure: warning: $ac_option: invalid host type" 1>&2 + fi + if test "x$nonopt" != xNONE; then + { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } + fi + nonopt="$ac_option" + ;; + + esac +done + +if test -n "$ac_prev"; then + { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; } +fi + +trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 + +# File descriptor usage: +# 0 standard input +# 1 file creation +# 2 errors and warnings +# 3 some systems may open it to /dev/tty +# 4 used on the Kubota Titan +# 6 checking for... messages and results +# 5 compiler messages saved in config.log +if test "$silent" = yes; then + exec 6>/dev/null +else + exec 6>&1 +fi +exec 5>./config.log + +echo "\ +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. +" 1>&5 + +# Strip out --no-create and --no-recursion so they do not pile up. +# Also quote any args containing shell metacharacters. +ac_configure_args= +for ac_arg +do + case "$ac_arg" in + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c) ;; + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;; + *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*) + ac_configure_args="$ac_configure_args '$ac_arg'" ;; + *) ac_configure_args="$ac_configure_args $ac_arg" ;; + esac +done + +# NLS nuisances. +# Only set these to C if already set. These must not be set unconditionally +# because not all systems understand e.g. LANG=C (notably SCO). +# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'! +# Non-C LC_CTYPE values break the ctype check. +if test "${LANG+set}" = set; then LANG=C; export LANG; fi +if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi +if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi +if test "${LC_CTYPE+set}" = set; then LC_CTYPE=C; export LC_CTYPE; fi + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -rf conftest* confdefs.h +# AIX cpp loses on an empty file, so make sure it contains at least a newline. +echo > confdefs.h + +# A filename unique to this package, relative to the directory that +# configure is in, which we can look for to find out if srcdir is correct. +ac_unique_file=java/lang/System.java + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then its parent. + ac_prog=$0 + ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'` + test "x$ac_confdir" = "x$ac_prog" && ac_confdir=. + srcdir=$ac_confdir + if test ! -r $srcdir/$ac_unique_file; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r $srcdir/$ac_unique_file; then + if test "$ac_srcdir_defaulted" = yes; then + { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; } + else + { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; } + fi +fi +srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'` + +# Prefer explicitly selected file to automatically selected ones. +if test -z "$CONFIG_SITE"; then + if test "x$prefix" != xNONE; then + CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site" + else + CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site" + fi +fi +for ac_site_file in $CONFIG_SITE; do + if test -r "$ac_site_file"; then + echo "loading site script $ac_site_file" + . "$ac_site_file" + fi +done + +if test -r "$cache_file"; then + echo "loading cache $cache_file" + . $cache_file +else + echo "creating cache $cache_file" + > $cache_file +fi + +ac_ext=c +# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. +ac_cpp='$CPP $CPPFLAGS' +ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5' +ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5' +cross_compiling=$ac_cv_prog_cc_cross + +ac_exeext= +ac_objext=o +if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then + # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu. + if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then + ac_n= ac_c=' +' ac_t=' ' + else + ac_n=-n ac_c= ac_t= + fi +else + ac_n= ac_c='\c' ac_t= +fi + + + +ac_aux_dir= +for ac_dir in .. $srcdir/..; do + if test -f $ac_dir/install-sh; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f $ac_dir/install.sh; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + fi +done +if test -z "$ac_aux_dir"; then + { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; } +fi +ac_config_guess=$ac_aux_dir/config.guess +ac_config_sub=$ac_aux_dir/config.sub +ac_configure=$ac_aux_dir/configure # This should be Cygnus configure. + + + +# Do some error checking and defaulting for the host and target type. +# The inputs are: +# configure --host=HOST --target=TARGET --build=BUILD NONOPT +# +# The rules are: +# 1. You are not allowed to specify --host, --target, and nonopt at the +# same time. +# 2. Host defaults to nonopt. +# 3. If nonopt is not specified, then host defaults to the current host, +# as determined by config.guess. +# 4. Target and build default to nonopt. +# 5. If nonopt is not specified, then target and build default to host. + +# The aliases save the names the user supplied, while $host etc. +# will get canonicalized. +case $host---$target---$nonopt in +NONE---*---* | *---NONE---* | *---*---NONE) ;; +*) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;; +esac + + +# Make sure we can run config.sub. +if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then : +else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; } +fi + +echo $ac_n "checking host system type""... $ac_c" 1>&6 +echo "configure:593: checking host system type" >&5 + +host_alias=$host +case "$host_alias" in +NONE) + case $nonopt in + NONE) + if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then : + else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; } + fi ;; + *) host_alias=$nonopt ;; + esac ;; +esac + +host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias` +host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` +host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` +host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` +echo "$ac_t""$host" 1>&6 + +echo $ac_n "checking target system type""... $ac_c" 1>&6 +echo "configure:614: checking target system type" >&5 + +target_alias=$target +case "$target_alias" in +NONE) + case $nonopt in + NONE) target_alias=$host_alias ;; + *) target_alias=$nonopt ;; + esac ;; +esac + +target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias` +target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` +target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` +target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` +echo "$ac_t""$target" 1>&6 + +echo $ac_n "checking build system type""... $ac_c" 1>&6 +echo "configure:632: checking build system type" >&5 + +build_alias=$build +case "$build_alias" in +NONE) + case $nonopt in + NONE) build_alias=$host_alias ;; + *) build_alias=$nonopt ;; + esac ;; +esac + +build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias` +build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` +build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` +build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` +echo "$ac_t""$build" 1>&6 + +test "$host_alias" != "$target_alias" && + test "$program_prefix$program_suffix$program_transform_name" = \ + NONENONEs,x,x, && + program_prefix=${target_alias}- + + +# Check whether --with-target-subdir or --without-target-subdir was given. +if test "${with_target_subdir+set}" = set; then + withval="$with_target_subdir" + : +fi + +# Check whether --with-cross-host or --without-cross-host was given. +if test "${with_cross_host+set}" = set; then + withval="$with_cross_host" + : +fi + + +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# ./install, which can be erroneously created by make from ./install.sh. +echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 +echo "configure:680: checking for a BSD compatible install" >&5 +if test -z "$INSTALL"; then +if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS=":" + for ac_dir in $PATH; do + # Account for people who put trailing slashes in PATH elements. + case "$ac_dir/" in + /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + if test -f $ac_dir/$ac_prog; then + if test $ac_prog = install && + grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + else + ac_cv_path_install="$ac_dir/$ac_prog -c" + break 2 + fi + fi + done + ;; + esac + done + IFS="$ac_save_IFS" + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL="$ac_cv_path_install" + else + # As a last resort, use the slow shell script. We don't cache a + # path for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the path is relative. + INSTALL="$ac_install_sh" + fi +fi +echo "$ac_t""$INSTALL" 1>&6 + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + +echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6 +echo "configure:733: checking whether build environment is sane" >&5 +# Just in case +sleep 1 +echo timestamp > conftestfile +# Do `set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null` + if test "$*" = "X"; then + # -L didn't work. + set X `ls -t $srcdir/configure conftestfile` + fi + if test "$*" != "X $srcdir/configure conftestfile" \ + && test "$*" != "X conftestfile $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + { echo "configure: error: ls -t appears to fail. Make sure there is not a broken +alias in your environment" 1>&2; exit 1; } + fi + + test "$2" = conftestfile + ) +then + # Ok. + : +else + { echo "configure: error: newly created file is older than distributed files! +Check your system clock" 1>&2; exit 1; } +fi +rm -f conftest* +echo "$ac_t""yes" 1>&6 +if test "$program_transform_name" = s,x,x,; then + program_transform_name= +else + # Double any \ or $. echo might interpret backslashes. + cat <<\EOF_SED > conftestsed +s,\\,\\\\,g; s,\$,$$,g +EOF_SED + program_transform_name="`echo $program_transform_name|sed -f conftestsed`" + rm -f conftestsed +fi +test "$program_prefix" != NONE && + program_transform_name="s,^,${program_prefix},; $program_transform_name" +# Use a double $ so make ignores it. +test "$program_suffix" != NONE && + program_transform_name="s,\$\$,${program_suffix},; $program_transform_name" + +# sed with no file args requires a program. +test "$program_transform_name" = "" && program_transform_name="s,x,x," + +echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6 +echo "configure:790: checking whether ${MAKE-make} sets \${MAKE}" >&5 +set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'` +if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftestmake <<\EOF +all: + @echo 'ac_maketemp="${MAKE}"' +EOF +# GNU make sometimes prints "make[1]: Entering...", which would confuse us. +eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=` +if test -n "$ac_maketemp"; then + eval ac_cv_prog_make_${ac_make}_set=yes +else + eval ac_cv_prog_make_${ac_make}_set=no +fi +rm -f conftestmake +fi +if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then + echo "$ac_t""yes" 1>&6 + SET_MAKE= +else + echo "$ac_t""no" 1>&6 + SET_MAKE="MAKE=${MAKE-make}" +fi + +if test $host != $build; then + ac_tool_prefix=${host_alias}- +else + ac_tool_prefix= +fi + +echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6 +echo "configure:823: checking for Cygwin environment" >&5 +if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + ac_cv_cygwin=yes +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + ac_cv_cygwin=no +fi +rm -f conftest* +rm -f conftest* +fi + +echo "$ac_t""$ac_cv_cygwin" 1>&6 +CYGWIN= +test "$ac_cv_cygwin" = yes && CYGWIN=yes +echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6 +echo "configure:856: checking for mingw32 environment" >&5 +if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + ac_cv_mingw32=yes +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + ac_cv_mingw32=no +fi +rm -f conftest* +rm -f conftest* +fi + +echo "$ac_t""$ac_cv_mingw32" 1>&6 +MINGW32= +test "$ac_cv_mingw32" = yes && MINGW32=yes + +# Check whether --enable-multilib or --disable-multilib was given. +if test "${enable_multilib+set}" = set; then + enableval="$enable_multilib" + case "${enableval}" in + yes) multilib=yes ;; + no) multilib=no ;; + *) { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;; + esac +else + multilib=yes +fi + + +if test "${srcdir}" = "."; then + if test "${with_target_subdir}" != "."; then + libgcj_basedir="${srcdir}/${with_multisrctop}../." + else + libgcj_basedir="${srcdir}/${with_multisrctop}." + fi +else + libgcj_basedir="${srcdir}/." +fi + + + +# Make sure we can run config.sub. +if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then : +else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; } +fi + +echo $ac_n "checking host system type""... $ac_c" 1>&6 +echo "configure:916: checking host system type" >&5 + +host_alias=$host +case "$host_alias" in +NONE) + case $nonopt in + NONE) + if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then : + else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; } + fi ;; + *) host_alias=$nonopt ;; + esac ;; +esac + +host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias` +host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` +host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` +host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` +echo "$ac_t""$host" 1>&6 + + + +PACKAGE=libjava + +VERSION=0.0.7 + +if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then + { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; } +fi +cat >> confdefs.h <> confdefs.h <&6 +echo "configure:957: checking for working aclocal" >&5 +# Run test in a subshell; some versions of sh will print an error if +# an executable is not found, even if stderr is redirected. +# Redirect stdin to placate older versions of autoconf. Sigh. +if (aclocal --version) < /dev/null > /dev/null 2>&1; then + ACLOCAL=aclocal + echo "$ac_t""found" 1>&6 +else + ACLOCAL="$missing_dir/missing aclocal" + echo "$ac_t""missing" 1>&6 +fi + +echo $ac_n "checking for working autoconf""... $ac_c" 1>&6 +echo "configure:970: checking for working autoconf" >&5 +# Run test in a subshell; some versions of sh will print an error if +# an executable is not found, even if stderr is redirected. +# Redirect stdin to placate older versions of autoconf. Sigh. +if (autoconf --version) < /dev/null > /dev/null 2>&1; then + AUTOCONF=autoconf + echo "$ac_t""found" 1>&6 +else + AUTOCONF="$missing_dir/missing autoconf" + echo "$ac_t""missing" 1>&6 +fi + +echo $ac_n "checking for working automake""... $ac_c" 1>&6 +echo "configure:983: checking for working automake" >&5 +# Run test in a subshell; some versions of sh will print an error if +# an executable is not found, even if stderr is redirected. +# Redirect stdin to placate older versions of autoconf. Sigh. +if (automake --version) < /dev/null > /dev/null 2>&1; then + AUTOMAKE=automake + echo "$ac_t""found" 1>&6 +else + AUTOMAKE="$missing_dir/missing automake" + echo "$ac_t""missing" 1>&6 +fi + +echo $ac_n "checking for working autoheader""... $ac_c" 1>&6 +echo "configure:996: checking for working autoheader" >&5 +# Run test in a subshell; some versions of sh will print an error if +# an executable is not found, even if stderr is redirected. +# Redirect stdin to placate older versions of autoconf. Sigh. +if (autoheader --version) < /dev/null > /dev/null 2>&1; then + AUTOHEADER=autoheader + echo "$ac_t""found" 1>&6 +else + AUTOHEADER="$missing_dir/missing autoheader" + echo "$ac_t""missing" 1>&6 +fi + +echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6 +echo "configure:1009: checking for working makeinfo" >&5 +# Run test in a subshell; some versions of sh will print an error if +# an executable is not found, even if stderr is redirected. +# Redirect stdin to placate older versions of autoconf. Sigh. +if (makeinfo --version) < /dev/null > /dev/null 2>&1; then + MAKEINFO=makeinfo + echo "$ac_t""found" 1>&6 +else + MAKEINFO="$missing_dir/missing makeinfo" + echo "$ac_t""missing" 1>&6 +fi + + + +# FIXME: We temporarily define our own version of AC_PROG_CC. This is +# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We +# are probably using a cross compiler, which will not be able to fully +# link an executable. This should really be fixed in autoconf +# itself. + + + +# Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +echo "configure:1034: checking for $ac_word" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_CC="gcc" + break + fi + done + IFS="$ac_save_ifs" +fi +fi +CC="$ac_cv_prog_CC" +if test -n "$CC"; then + echo "$ac_t""$CC" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +echo "configure:1064: checking for $ac_word" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_prog_rejected=no + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + break + fi + done + IFS="$ac_save_ifs" +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# -gt 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + set dummy "$ac_dir/$ac_word" "$@" + shift + ac_cv_prog_CC="$@" + fi +fi +fi +fi +CC="$ac_cv_prog_CC" +if test -n "$CC"; then + echo "$ac_t""$CC" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + + test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; } +fi + +echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6 +echo "configure:1113: checking whether we are using GNU C" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.c <&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then + ac_cv_prog_gcc=yes +else + ac_cv_prog_gcc=no +fi +fi + +echo "$ac_t""$ac_cv_prog_gcc" 1>&6 + +if test $ac_cv_prog_gcc = yes; then + GCC=yes + ac_test_CFLAGS="${CFLAGS+set}" + ac_save_CFLAGS="$CFLAGS" + CFLAGS= + echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6 +echo "configure:1137: checking whether ${CC-cc} accepts -g" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + echo 'void f(){}' > conftest.c +if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then + ac_cv_prog_cc_g=yes +else + ac_cv_prog_cc_g=no +fi +rm -f conftest* + +fi + +echo "$ac_t""$ac_cv_prog_cc_g" 1>&6 + if test "$ac_test_CFLAGS" = set; then + CFLAGS="$ac_save_CFLAGS" + elif test $ac_cv_prog_cc_g = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-O2" + fi +else + GCC= + test "${CFLAGS+set}" = set || CFLAGS="-g" +fi + + +# Likewise for AC_PROG_CXX. + + +for ac_prog in $CCC c++ g++ gcc CC cxx cc++ +do +# Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +echo "configure:1173: checking for $ac_word" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$CXX"; then + ac_cv_prog_CXX="$CXX" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_CXX="$ac_prog" + break + fi + done + IFS="$ac_save_ifs" +fi +fi +CXX="$ac_cv_prog_CXX" +if test -n "$CXX"; then + echo "$ac_t""$CXX" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + +test -n "$CXX" && break +done +test -n "$CXX" || CXX="gcc" + +test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; } + +echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6 +echo "configure:1206: checking whether we are using GNU C++" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.C <&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then + ac_cv_prog_gxx=yes +else + ac_cv_prog_gxx=no +fi +fi + +echo "$ac_t""$ac_cv_prog_gxx" 1>&6 + +if test $ac_cv_prog_gxx = yes; then + GXX=yes + ac_test_CXXFLAGS="${CXXFLAGS+set}" + ac_save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS= + echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6 +echo "configure:1230: checking whether ${CXX-g++} accepts -g" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + echo 'void f(){}' > conftest.cc +if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then + ac_cv_prog_cxx_g=yes +else + ac_cv_prog_cxx_g=no +fi +rm -f conftest* + +fi + +echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6 + if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS="$ac_save_CXXFLAGS" + elif test $ac_cv_prog_cxx_g = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-O2" + fi +else + GXX= + test "${CXXFLAGS+set}" = set || CXXFLAGS="-g" +fi + + +# AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD). If we dont +# run it explicitly here, it will be run implicitly before +# LIBGCJ_CONFIGURE, which doesn't work because that means that it will +# be run before AC_CANONICAL_HOST. +echo $ac_n "checking build system type""... $ac_c" 1>&6 +echo "configure:1263: checking build system type" >&5 + +build_alias=$build +case "$build_alias" in +NONE) + case $nonopt in + NONE) build_alias=$host_alias ;; + *) build_alias=$nonopt ;; + esac ;; +esac + +build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias` +build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` +build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` +build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` +echo "$ac_t""$build" 1>&6 + + +# Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args. +set dummy ${ac_tool_prefix}as; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +echo "configure:1284: checking for $ac_word" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$AS"; then + ac_cv_prog_AS="$AS" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_AS="${ac_tool_prefix}as" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as" +fi +fi +AS="$ac_cv_prog_AS" +if test -n "$AS"; then + echo "$ac_t""$AS" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + + + +# Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args. +set dummy ${ac_tool_prefix}ar; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +echo "configure:1316: checking for $ac_word" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_AR="${ac_tool_prefix}ar" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar" +fi +fi +AR="$ac_cv_prog_AR" +if test -n "$AR"; then + echo "$ac_t""$AR" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + + + +# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. +set dummy ${ac_tool_prefix}ranlib; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +echo "configure:1348: checking for $ac_word" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" + break + fi + done + IFS="$ac_save_ifs" +fi +fi +RANLIB="$ac_cv_prog_RANLIB" +if test -n "$RANLIB"; then + echo "$ac_t""$RANLIB" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + + +if test -z "$ac_cv_prog_RANLIB"; then +if test -n "$ac_tool_prefix"; then + # Extract the first word of "ranlib", so it can be a program name with args. +set dummy ranlib; ac_word=$2 +echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 +echo "configure:1380: checking for $ac_word" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_RANLIB="ranlib" + break + fi + done + IFS="$ac_save_ifs" + test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":" +fi +fi +RANLIB="$ac_cv_prog_RANLIB" +if test -n "$RANLIB"; then + echo "$ac_t""$RANLIB" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + +else + RANLIB=":" +fi +fi + + +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# ./install, which can be erroneously created by make from ./install.sh. +echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 +echo "configure:1425: checking for a BSD compatible install" >&5 +if test -z "$INSTALL"; then +if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS=":" + for ac_dir in $PATH; do + # Account for people who put trailing slashes in PATH elements. + case "$ac_dir/" in + /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + if test -f $ac_dir/$ac_prog; then + if test $ac_prog = install && + grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + else + ac_cv_path_install="$ac_dir/$ac_prog -c" + break 2 + fi + fi + done + ;; + esac + done + IFS="$ac_save_IFS" + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL="$ac_cv_path_install" + else + # As a last resort, use the slow shell script. We don't cache a + # path for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the path is relative. + INSTALL="$ac_install_sh" + fi +fi +echo "$ac_t""$INSTALL" 1>&6 + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + + +echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6 +echo "configure:1479: checking whether to enable maintainer-specific portions of Makefiles" >&5 + # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given. +if test "${enable_maintainer_mode+set}" = set; then + enableval="$enable_maintainer_mode" + USE_MAINTAINER_MODE=$enableval +else + USE_MAINTAINER_MODE=no +fi + + echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6 + + +if test $USE_MAINTAINER_MODE = yes; then + MAINTAINER_MODE_TRUE= + MAINTAINER_MODE_FALSE='#' +else + MAINTAINER_MODE_TRUE='#' + MAINTAINER_MODE_FALSE= +fi + MAINT=$MAINTAINER_MODE_TRUE + + + +# We need AC_EXEEXT to keep automake happy in cygnus mode. However, +# at least currently, we never actually build a program, so we never +# need to use $(EXEEXT). Moreover, the test for EXEEXT normally +# fails, because we are probably configuring with a cross compiler +# which cant create executables. So we include AC_EXEEXT to keep +# automake happy, but we dont execute it, since we dont care about +# the result. +if false; then + + +echo $ac_n "checking for executable suffix""... $ac_c" 1>&6 +echo "configure:1513: checking for executable suffix" >&5 +if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test "$CYGWIN" = yes || test "$MINGW32" = yes; then + ac_cv_exeext=.exe +else + rm -f conftest* + echo 'int main () { return 0; }' > conftest.$ac_ext + ac_cv_exeext= + if { (eval echo configure:1523: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then + for file in conftest.*; do + case $file in + *.c | *.o | *.obj | *.ilk | *.pdb) ;; + *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;; + esac + done + else + { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; } + fi + rm -f conftest* + test x"${ac_cv_exeext}" = x && ac_cv_exeext=no +fi +fi + +EXEEXT="" +test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext} +echo "$ac_t""${ac_cv_exeext}" 1>&6 +ac_exeext=$EXEEXT + +fi + +# configure.host sets the following important variables +# libgcj_cflags - host specific C compiler flags +# libgcj_cxxflags - host specific C++ compiler flags +# libgcj_javaflags - host specific Java compiler flags + +libgcj_cflags= +libgcj_cxxflags= +libgcj_javaflags= + +. ${libgcj_basedir}/configure.host + +case ${libgcj_basedir} in +/* | A-Za-z:/\\*) libgcj_flagbasedir=${libgcj_basedir} ;; +*) libgcj_flagbasedir='$(top_builddir)/'${libgcj_basedir} ;; +esac + +LIBGCJ_CFLAGS="${libgcj_cflags}" +LIBGCJ_CXXFLAGS="${libgcj_cxxflags}" +LIBGCJ_JAVAFLAGS="${libgcj_javaflags}" + + + + + + + + + +if test -z "$with_target_subdir" || test "$with_target_subdir" = "."; then + COMPPATH=. +else + COMPPATH=.. +fi + + + + +if test -d $srcdir/testsuite; then + TESTSUBDIR_TRUE= + TESTSUBDIR_FALSE='#' +else + TESTSUBDIR_TRUE='#' + TESTSUBDIR_FALSE= +fi + +# Check whether --enable-fast-character or --disable-fast-character was given. +if test "${enable_fast_character+set}" = set; then + enableval="$enable_fast_character" + # Nothing + +else + cat >> confdefs.h <<\EOF +#define COMPACT_CHARACTER 1 +EOF + +fi + + +# Check whether --enable-libgcj-debug or --disable-libgcj-debug was given. +if test "${enable_libgcj_debug+set}" = set; then + enableval="$enable_libgcj_debug" + if test "$enable_libgcj_debug" = yes; then + cat >> confdefs.h <<\EOF +#define DEBUG 1 +EOF + + fi +fi + + +TARGET_ECOS="no" +# Check whether --with-ecos or --without-ecos was given. +if test "${with_ecos+set}" = set; then + withval="$with_ecos" + TARGET_ECOS="$with_ecos" + +fi + + +case "$TARGET_ECOS" in + no) + FILE_DESCRIPTOR=natFileDescriptorPosix.cc + ;; + *) + FILE_DESCRIPTOR=natFileDescriptorEcos.cc + cat >> confdefs.h <<\EOF +#define ECOS 1 +EOF + + ;; +esac + +echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6 +echo "configure:1638: checking how to run the C preprocessor" >&5 +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then +if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + # This must be in double quotes, not single quotes, because CPP may get + # substituted into the Makefile and "${CC-cc}" will confuse make. + CPP="${CC-cc} -E" + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. + cat > conftest.$ac_ext < +Syntax Error +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:1659: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` +if test -z "$ac_err"; then + : +else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + CPP="${CC-cc} -E -traditional-cpp" + cat > conftest.$ac_ext < +Syntax Error +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:1676: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` +if test -z "$ac_err"; then + : +else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + CPP="${CC-cc} -nologo -E" + cat > conftest.$ac_ext < +Syntax Error +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:1693: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` +if test -z "$ac_err"; then + : +else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + CPP=/lib/cpp +fi +rm -f conftest* +fi +rm -f conftest* +fi +rm -f conftest* + ac_cv_prog_CPP="$CPP" +fi + CPP="$ac_cv_prog_CPP" +else + ac_cv_prog_CPP="$CPP" +fi +echo "$ac_t""$CPP" 1>&6 + +cat > conftest.$ac_ext < +EOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "__uint32_t" >/dev/null 2>&1; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define HAVE_INT32_DEFINED 1 +EOF + +fi +rm -f conftest* + +cat > conftest.$ac_ext < +EOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "__uint32_t" >/dev/null 2>&1; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define HAVE_INT32_DEFINED 1 +EOF + +fi +rm -f conftest* + + +cat > conftest.$ac_ext < +EOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "mktime" >/dev/null 2>&1; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define HAVE_MKTIME 1 +EOF + +fi +rm -f conftest* + +cat > conftest.$ac_ext < +EOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "localtime" >/dev/null 2>&1; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define HAVE_LOCALTIME 1 +EOF + +fi +rm -f conftest* + + +test -d java || mkdir java +test -d java/io || mkdir java/io + + +echo $ac_n "checking for garbage collector to use""... $ac_c" 1>&6 +echo "configure:1784: checking for garbage collector to use" >&5 +# Check whether --enable-java-gc or --disable-java-gc was given. +if test "${enable_java_gc+set}" = set; then + enableval="$enable_java_gc" + + GC=$enableval +else + GC=boehm +fi + +GCLIBS= +GCINCS= +GCDEPS= +GCOBJS= +case "$GC" in + boehm) + echo "$ac_t""boehm" 1>&6 + GCLIBS='-L$(top_builddir)/../boehm-gc -lgcjgc' + GCDEPS='$(top_builddir)/../boehm-gc/libgcjgc.a' + GCINCS='-I$(top_srcdir)/../boehm-gc -I$(top_builddir)/../boehm-gc' + GCINCS="$GCINCS `cat ../boehm-gc/boehm-cflags`" + GCOBJS=boehm.o + GCHDR=boehm-gc.h + cat >> confdefs.h <<\EOF +#define HAVE_BOEHM_GC 1 +EOF + + ;; + no) + echo "$ac_t""none" 1>&6 + GCOBJS=nogc.o + GCHDR=no-gc.h + ;; + *) + { echo "configure: error: unrecognized collector \"$GC\"" 1>&2; exit 1; } + ;; +esac + + + + + + + +echo $ac_n "checking for threads package to use""... $ac_c" 1>&6 +echo "configure:1829: checking for threads package to use" >&5 +# Check whether --enable-threads or --disable-threads was given. +if test "${enable_threads+set}" = set; then + enableval="$enable_threads" + THREADS=$enableval +else + THREADS=no +fi + + +if test "$THREADS" = yes; then + case "$host" in + *-*-vxworks*) + THREADS=vxworks + ;; + *-*-linux*) + # FIXME: this isn't correct in all cases. + THREADS=posix + ;; + *-*-win*) + THREADS=win32 + ;; + *-*-irix*) + THREADS=irix + ;; + *-*-solaris*) + # FIXME: for now, choose POSIX, because we implement that. + # Later, choose solaris threads. + THREADS=posix + ;; + *) + # For now. + THREADS=none + ;; + esac +fi + +case "$THREADS" in + no | none | single) + THREADS=none + ;; + posix | pthreads) + THREADS=posix + case "$host" in + *-*-linux*) + cat >> confdefs.h <<\EOF +#define LINUX_THREADS 1 +EOF + + ;; + esac + ;; + qt) + ;; + decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks) + { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; } + ;; + *) + { echo "configure: error: $THREADS is an unknown thread package" 1>&2; exit 1; } + ;; +esac +echo "$ac_t""$THREADS" 1>&6 + +THREADLIBS= +THREADINCS= +THREADDEPS= +THREADOBJS= +THREADH= +case "$THREADS" in + posix) + THREADLIBS=-lpthread + THREADOBJS=posix-threads.o + THREADH=posix-threads.h + # MIT pthreads doesn't seem to have the mutexattr functions. + # But for now we don't check for it. We just assume you aren't + # using MIT pthreads. + cat >> confdefs.h <<\EOF +#define HAVE_PTHREAD_MUTEXATTR_INIT 1 +EOF + + ;; + + qt) + THREADLIBS='-L$(top_builddir)/../qthreads -lgcjcoop' + THREADOBJS=quick-threads.o + THREADINCS='-I$(top_srcdir)/../qthreads' + THREADH=quick-threads.h + THREADDEPS='$(top_builddir)/../qthreads/libgcjcoop.a' + ;; + + none) + THREADOBJS=no-threads.o + THREADH=no-threads.h + ;; +esac + + + + + + + + +if test "$GCC" = yes; then + USING_GCC_TRUE= + USING_GCC_FALSE='#' +else + USING_GCC_TRUE='#' + USING_GCC_FALSE= +fi + +CANADIAN=no +NULL_TARGET=no + +# Find eh-common.h and support headers. If we're in the tree with +# gcc, then look there. Otherwise look in compat-include. If all else +# fails, just hope the user has set things up somehow. +if test -r $srcdir/../gcc/eh-common.h; then + EH_COMMON_INCLUDE='-I$(top_srcdir)/../gcc -I$(top_srcdir)/../include' +else + if test -d $srcdir/../compat-include; then + EH_COMMON_INCLUDE='-I$(top_srcdir)/../compat-include' + else + EH_COMMON_INCLUDE= + fi +fi + +if test -n "${with_cross_host}"; then + # We are being configured with a cross compiler. AC_REPLACE_FUNCS + # may not work correctly, because the compiler may not be able to + # link executables. + + # We assume newlib. This lets us hard-code the functions we know + # we'll have. + cat >> confdefs.h <<\EOF +#define HAVE_MEMMOVE 1 +EOF + + cat >> confdefs.h <<\EOF +#define HAVE_MEMCPY 1 +EOF + + cat >> confdefs.h <<\EOF +#define HAVE_STRERROR 1 +EOF + + cat >> confdefs.h <<\EOF +#define HAVE_CTIME_R 1 +EOF + + cat >> confdefs.h <<\EOF +#define HAVE_GMTIME_R 1 +EOF + + cat >> confdefs.h <<\EOF +#define HAVE_LOCALTIME_R 1 +EOF + + cat >> confdefs.h <<\EOF +#define HAVE_PTHREAD_MUTEXATTR_INIT 1 +EOF + + cat >> confdefs.h <<\EOF +#define HAVE_ALLOCA 1 +EOF + + + # If Canadian cross, then don't pick up tools from the build + # directory. + if test "$build" != "$with_cross_host"; then + CANADIAN=yes + EH_COMMON_INCLUDE= + fi +else + # Some POSIX thread systems don't have pthread_mutexattr_settype. + # E.g., Solaris. + for ac_func in strerror ioctl select open fsync sleep +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2008: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2036: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + for ac_func in ctime_r ctime +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2063: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2091: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + for ac_func in gmtime_r localtime_r readdir_r getpwuid_r +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2118: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2146: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + for ac_func in access stat mkdir rename rmdir unlink realpath +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2173: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2201: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + for ac_func in inet_aton inet_addr +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2228: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2256: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + for ac_func in inet_pton uname +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2283: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2311: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + + for ac_func in gethostbyname_r +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2339: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2367: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <> confdefs.h <<\EOF +#define HAVE_GETHOSTBYNAME_R 1 +EOF + + # There are two different kinds of gethostbyname_r. + # We look for the one that returns `int'. + # Hopefully this check is robust enough. + cat > conftest.$ac_ext < +EOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "int.*gethostbyname_r" >/dev/null 2>&1; then + rm -rf conftest* + + cat >> confdefs.h <<\EOF +#define GETHOSTBYNAME_R_RETURNS_INT 1 +EOF + +fi +rm -f conftest* + +else + echo "$ac_t""no" 1>&6 +fi +done + + + for ac_func in gethostbyaddr_r +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2418: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2446: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <> confdefs.h <<\EOF +#define HAVE_GETHOSTBYADDR_R 1 +EOF + + # There are two different kinds of gethostbyaddr_r. + # We look for the one that returns `int'. + # Hopefully this check is robust enough. + cat > conftest.$ac_ext < +EOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "int.*gethostbyaddr_r" >/dev/null 2>&1; then + rm -rf conftest* + + cat >> confdefs.h <<\EOF +#define GETHOSTBYADDR_R_RETURNS_INT 1 +EOF + +fi +rm -f conftest* + +else + echo "$ac_t""no" 1>&6 +fi +done + + + for ac_func in gethostname +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2497: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2525: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <> confdefs.h <<\EOF +#define HAVE_GETHOSTNAME 1 +EOF + + cat > conftest.$ac_ext < +EOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + egrep "gethostname" >/dev/null 2>&1; then + rm -rf conftest* + + cat >> confdefs.h <<\EOF +#define HAVE_GETHOSTNAME_DECL 1 +EOF + +fi +rm -f conftest* + +else + echo "$ac_t""no" 1>&6 +fi +done + + + # Look for these functions in the thread library. + save_LIBS="$LIBS" + LIBS="$LIBS $THREADLIBS" + for ac_func in pthread_mutexattr_settype pthread_mutexattr_setkind_np sched_yield +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2576: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2604: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + LIBS="$save_LIBS" + + # We require a way to get the time. + time_found=no + for ac_func in gettimeofday time ftime +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2635: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2663: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + if test "$time_found" = no; then + { echo "configure: error: no function found to get the time" 1>&2; exit 1; } + fi + + # We require memmove. + memmove_found=no + for ac_func in memmove +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2696: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2724: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + if test "$memmove_found" = no; then + { echo "configure: error: memmove is required" 1>&2; exit 1; } + fi + + # We require memcpy. + memcpy_found=no + for ac_func in memcpy +do +echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:2757: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:2785: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` + cat >> confdefs.h <&6 +fi +done + + if test "$memcpy_found" = no; then + { echo "configure: error: memcpy is required" 1>&2; exit 1; } + fi + + test -d "$libgcj_basedir/../gcc/java" || { + CANADIAN=yes + NULL_TARGET=yes + } +fi + + + +if test "$CANADIAN" = yes; then + CANADIAN_TRUE= + CANADIAN_FALSE='#' +else + CANADIAN_TRUE='#' + CANADIAN_FALSE= +fi + + +if test "$NULL_TARGET" = yes; then + NULL_TARGET_TRUE= + NULL_TARGET_FALSE='#' +else + NULL_TARGET_TRUE='#' + NULL_TARGET_FALSE= +fi + + +if test "$CANADIAN" = no || test "$NULL_TARGET" = yes; then + NATIVE_TRUE= + NATIVE_FALSE='#' +else + NATIVE_TRUE='#' + NATIVE_FALSE= +fi + + + + + +for ac_hdr in unistd.h sys/time.h sys/types.h fcntl.h sys/ioctl.h sys/filio.h sys/stat.h sys/select.h sys/socket.h netinet/in.h arpa/inet.h netdb.h pwd.h +do +ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` +echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 +echo "configure:2855: checking for $ac_hdr" >&5 +if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:2865: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` +if test -z "$ac_err"; then + rm -rf conftest* + eval "ac_cv_header_$ac_safe=yes" +else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_header_$ac_safe=no" +fi +rm -f conftest* +fi +if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'` + cat >> confdefs.h <&6 +fi +done + +for ac_hdr in dirent.h +do +ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'` +echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6 +echo "configure:2895: checking for $ac_hdr" >&5 +if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +EOF +ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out" +{ (eval echo configure:2905: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } +ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"` +if test -z "$ac_err"; then + rm -rf conftest* + eval "ac_cv_header_$ac_safe=yes" +else + echo "$ac_err" >&5 + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_header_$ac_safe=no" +fi +rm -f conftest* +fi +if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then + echo "$ac_t""yes" 1>&6 + ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'` + cat >> confdefs.h <&6 +fi +done + + +echo $ac_n "checking whether struct sockaddr_in6 is in netinet/in.h""... $ac_c" 1>&6 +echo "configure:2933: checking whether struct sockaddr_in6 is in netinet/in.h" >&5 +cat > conftest.$ac_ext < +int main() { +struct sockaddr_in6 addr6; +; return 0; } +EOF +if { (eval echo configure:2942: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define HAVE_INET6 1 +EOF + + echo "$ac_t""yes" 1>&6 +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + echo "$ac_t""no" 1>&6 +fi +rm -f conftest* + +echo $ac_n "checking for socklen_t in sys/socket.h""... $ac_c" 1>&6 +echo "configure:2958: checking for socklen_t in sys/socket.h" >&5 +cat > conftest.$ac_ext < +int main() { +socklen_t x = 5; +; return 0; } +EOF +if { (eval echo configure:2967: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define HAVE_SOCKLEN_T 1 +EOF + + echo "$ac_t""yes" 1>&6 +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + echo "$ac_t""no" 1>&6 +fi +rm -f conftest* + +echo $ac_n "checking for tm_gmtoff in struct tm""... $ac_c" 1>&6 +echo "configure:2983: checking for tm_gmtoff in struct tm" >&5 +cat > conftest.$ac_ext < +int main() { +struct tm tim; tim.tm_gmtoff = 0; +; return 0; } +EOF +if { (eval echo configure:2992: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define STRUCT_TM_HAS_GMTOFF 1 +EOF + + echo "$ac_t""yes" 1>&6 +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + echo "$ac_t""no" 1>&6 + echo $ac_n "checking for global timezone variable""... $ac_c" 1>&6 +echo "configure:3005: checking for global timezone variable" >&5 + cat > conftest.$ac_ext < +int main() { +long z2 = timezone; +; return 0; } +EOF +if { (eval echo configure:3014: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then + rm -rf conftest* + cat >> confdefs.h <<\EOF +#define HAVE_TIMEZONE 1 +EOF + + echo "$ac_t""yes" 1>&6 +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + echo "$ac_t""no" 1>&6 +fi +rm -f conftest* +fi +rm -f conftest* + +# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works +# for constant arguments. Useless! +echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6 +echo "configure:3034: checking for working alloca.h" >&5 +if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +int main() { +char *p = alloca(2 * sizeof(int)); +; return 0; } +EOF +if { (eval echo configure:3046: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + ac_cv_header_alloca_h=yes +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + ac_cv_header_alloca_h=no +fi +rm -f conftest* +fi + +echo "$ac_t""$ac_cv_header_alloca_h" 1>&6 +if test $ac_cv_header_alloca_h = yes; then + cat >> confdefs.h <<\EOF +#define HAVE_ALLOCA_H 1 +EOF + +fi + +echo $ac_n "checking for alloca""... $ac_c" 1>&6 +echo "configure:3067: checking for alloca" >&5 +if eval "test \"`echo '$''{'ac_cv_func_alloca_works'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +# define alloca _alloca +# else +# if HAVE_ALLOCA_H +# include +# else +# ifdef _AIX + #pragma alloca +# else +# ifndef alloca /* predefined by HP cc +Olibcalls */ +char *alloca (); +# endif +# endif +# endif +# endif +#endif + +int main() { +char *p = (char *) alloca(1); +; return 0; } +EOF +if { (eval echo configure:3100: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + ac_cv_func_alloca_works=yes +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + ac_cv_func_alloca_works=no +fi +rm -f conftest* +fi + +echo "$ac_t""$ac_cv_func_alloca_works" 1>&6 +if test $ac_cv_func_alloca_works = yes; then + cat >> confdefs.h <<\EOF +#define HAVE_ALLOCA 1 +EOF + +fi + +if test $ac_cv_func_alloca_works = no; then + # The SVR3 libPW and SVR4 libucb both contain incompatible functions + # that cause trouble. Some versions do not even contain alloca or + # contain a buggy version. If you still want to use their alloca, + # use ar to extract alloca.o from them instead of compiling alloca.c. + ALLOCA=alloca.${ac_objext} + cat >> confdefs.h <<\EOF +#define C_ALLOCA 1 +EOF + + +echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6 +echo "configure:3132: checking whether alloca needs Cray hooks" >&5 +if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext <&5 | + egrep "webecray" >/dev/null 2>&1; then + rm -rf conftest* + ac_cv_os_cray=yes +else + rm -rf conftest* + ac_cv_os_cray=no +fi +rm -f conftest* + +fi + +echo "$ac_t""$ac_cv_os_cray" 1>&6 +if test $ac_cv_os_cray = yes; then +for ac_func in _getb67 GETB67 getb67; do + echo $ac_n "checking for $ac_func""... $ac_c" 1>&6 +echo "configure:3162: checking for $ac_func" >&5 +if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + cat > conftest.$ac_ext < +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char $ac_func(); + +int main() { + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined (__stub_$ac_func) || defined (__stub___$ac_func) +choke me +#else +$ac_func(); +#endif + +; return 0; } +EOF +if { (eval echo configure:3190: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then + rm -rf conftest* + eval "ac_cv_func_$ac_func=yes" +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -rf conftest* + eval "ac_cv_func_$ac_func=no" +fi +rm -f conftest* +fi + +if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then + echo "$ac_t""yes" 1>&6 + cat >> confdefs.h <&6 +fi + +done +fi + +echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6 +echo "configure:3217: checking stack direction for C alloca" >&5 +if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test "$cross_compiling" = yes; then + ac_cv_c_stack_direction=0 +else + cat > conftest.$ac_ext < addr) ? 1 : -1; +} +main () +{ + exit (find_stack_direction() < 0); +} +EOF +if { (eval echo configure:3244: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +then + ac_cv_c_stack_direction=1 +else + echo "configure: failed program was:" >&5 + cat conftest.$ac_ext >&5 + rm -fr conftest* + ac_cv_c_stack_direction=-1 +fi +rm -fr conftest* +fi + +fi + +echo "$ac_t""$ac_cv_c_stack_direction" 1>&6 +cat >> confdefs.h <&6 +echo "configure:3271: checking for $ac_word" >&5 +if eval "test \"`echo '$''{'ac_cv_prog_PERL'+set}'`\" = set"; then + echo $ac_n "(cached) $ac_c" 1>&6 +else + if test -n "$PERL"; then + ac_cv_prog_PERL="$PERL" # Let the user override the test. +else + IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":" + ac_dummy="$PATH" + for ac_dir in $ac_dummy; do + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$ac_word; then + ac_cv_prog_PERL="$ac_prog" + break + fi + done + IFS="$ac_save_ifs" +fi +fi +PERL="$ac_cv_prog_PERL" +if test -n "$PERL"; then + echo "$ac_t""$PERL" 1>&6 +else + echo "$ac_t""no" 1>&6 +fi + +test -n "$PERL" && break +done +test -n "$PERL" || PERL="false" + + +if test "${multilib}" = "yes"; then + multilib_arg="--enable-multilib" +else + multilib_arg= +fi + +here=`pwd` + + +trap '' 1 2 15 +cat > confcache <<\EOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs. It is not useful on other systems. +# If it contains results you don't want to keep, you may remove or edit it. +# +# By default, configure uses ./config.cache as the cache file, +# creating it if it does not exist already. You can give configure +# the --cache-file=FILE option to use a different cache file; that is +# what configure does when it calls configure scripts in +# subdirectories, so they share the cache. +# Giving --cache-file=/dev/null disables caching, for debugging configure. +# config.status only pays attention to the cache file if you give it the +# --recheck option to rerun configure. +# +EOF +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, don't put newlines in cache variables' values. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +(set) 2>&1 | + case `(ac_space=' '; set | grep ac_space) 2>&1` in + *ac_space=\ *) + # `set' does not quote correctly, so add quotes (double-quote substitution + # turns \\\\ into \\, and sed turns \\ into \). + sed -n \ + -e "s/'/'\\\\''/g" \ + -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p" + ;; + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p' + ;; + esac >> confcache +if cmp -s $cache_file confcache; then + : +else + if test -w $cache_file; then + echo "updating cache $cache_file" + cat confcache > $cache_file + else + echo "not updating unwritable cache $cache_file" + fi +fi +rm -f confcache + +trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15 + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +# Any assignment to VPATH causes Sun make to only execute +# the first set of double-colon rules, so remove it if not needed. +# If there is a colon in the path, we need to keep it. +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[^:]*$/d' +fi + +trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15 + +DEFS=-DHAVE_CONFIG_H + +# Without the "./", some shells look in PATH for config.status. +: ${CONFIG_STATUS=./config.status} + +echo creating $CONFIG_STATUS +rm -f $CONFIG_STATUS +cat > $CONFIG_STATUS </dev/null | sed 1q`: +# +# $0 $ac_configure_args +# +# Compiler output produced by configure, useful for debugging +# configure, is in ./config.log if it exists. + +ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]" +for ac_option +do + case "\$ac_option" in + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion" + exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;; + -version | --version | --versio | --versi | --vers | --ver | --ve | --v) + echo "$CONFIG_STATUS generated by autoconf version 2.13" + exit 0 ;; + -help | --help | --hel | --he | --h) + echo "\$ac_cs_usage"; exit 0 ;; + *) echo "\$ac_cs_usage"; exit 1 ;; + esac +done + +ac_given_srcdir=$srcdir +ac_given_INSTALL="$INSTALL" + +trap 'rm -fr `echo "Makefile testsuite/Makefile include/config.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15 +EOF +cat >> $CONFIG_STATUS < conftest.subs <<\\CEOF +$ac_vpsub +$extrasub +s%@SHELL@%$SHELL%g +s%@CFLAGS@%$CFLAGS%g +s%@CPPFLAGS@%$CPPFLAGS%g +s%@CXXFLAGS@%$CXXFLAGS%g +s%@FFLAGS@%$FFLAGS%g +s%@DEFS@%$DEFS%g +s%@LDFLAGS@%$LDFLAGS%g +s%@LIBS@%$LIBS%g +s%@exec_prefix@%$exec_prefix%g +s%@prefix@%$prefix%g +s%@program_transform_name@%$program_transform_name%g +s%@bindir@%$bindir%g +s%@sbindir@%$sbindir%g +s%@libexecdir@%$libexecdir%g +s%@datadir@%$datadir%g +s%@sysconfdir@%$sysconfdir%g +s%@sharedstatedir@%$sharedstatedir%g +s%@localstatedir@%$localstatedir%g +s%@libdir@%$libdir%g +s%@includedir@%$includedir%g +s%@oldincludedir@%$oldincludedir%g +s%@infodir@%$infodir%g +s%@mandir@%$mandir%g +s%@host@%$host%g +s%@host_alias@%$host_alias%g +s%@host_cpu@%$host_cpu%g +s%@host_vendor@%$host_vendor%g +s%@host_os@%$host_os%g +s%@target@%$target%g +s%@target_alias@%$target_alias%g +s%@target_cpu@%$target_cpu%g +s%@target_vendor@%$target_vendor%g +s%@target_os@%$target_os%g +s%@build@%$build%g +s%@build_alias@%$build_alias%g +s%@build_cpu@%$build_cpu%g +s%@build_vendor@%$build_vendor%g +s%@build_os@%$build_os%g +s%@libgcj_basedir@%$libgcj_basedir%g +s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g +s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g +s%@INSTALL_DATA@%$INSTALL_DATA%g +s%@PACKAGE@%$PACKAGE%g +s%@VERSION@%$VERSION%g +s%@ACLOCAL@%$ACLOCAL%g +s%@AUTOCONF@%$AUTOCONF%g +s%@AUTOMAKE@%$AUTOMAKE%g +s%@AUTOHEADER@%$AUTOHEADER%g +s%@MAKEINFO@%$MAKEINFO%g +s%@SET_MAKE@%$SET_MAKE%g +s%@CC@%$CC%g +s%@CXX@%$CXX%g +s%@AS@%$AS%g +s%@AR@%$AR%g +s%@RANLIB@%$RANLIB%g +s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g +s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g +s%@MAINT@%$MAINT%g +s%@EXEEXT@%$EXEEXT%g +s%@LIBGCJ_CFLAGS@%$LIBGCJ_CFLAGS%g +s%@LIBGCJ_CXXFLAGS@%$LIBGCJ_CXXFLAGS%g +s%@LIBGCJ_JAVAFLAGS@%$LIBGCJ_JAVAFLAGS%g +s%@COMPPATH@%$COMPPATH%g +s%@TESTSUBDIR_TRUE@%$TESTSUBDIR_TRUE%g +s%@TESTSUBDIR_FALSE@%$TESTSUBDIR_FALSE%g +s%@CPP@%$CPP%g +s%@GCLIBS@%$GCLIBS%g +s%@GCINCS@%$GCINCS%g +s%@GCDEPS@%$GCDEPS%g +s%@GCOBJS@%$GCOBJS%g +s%@THREADLIBS@%$THREADLIBS%g +s%@THREADINCS@%$THREADINCS%g +s%@THREADDEPS@%$THREADDEPS%g +s%@THREADOBJS@%$THREADOBJS%g +s%@USING_GCC_TRUE@%$USING_GCC_TRUE%g +s%@USING_GCC_FALSE@%$USING_GCC_FALSE%g +s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g +s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g +s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g +s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g +s%@NATIVE_TRUE@%$NATIVE_TRUE%g +s%@NATIVE_FALSE@%$NATIVE_FALSE%g +s%@EH_COMMON_INCLUDE@%$EH_COMMON_INCLUDE%g +s%@AM_RUNTESTFLAGS@%$AM_RUNTESTFLAGS%g +s%@ALLOCA@%$ALLOCA%g +s%@PERL@%$PERL%g +s%@here@%$here%g + +CEOF +EOF + +cat >> $CONFIG_STATUS <<\EOF + +# Split the substitutions into bite-sized pieces for seds with +# small command number limits, like on Digital OSF/1 and HP-UX. +ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script. +ac_file=1 # Number of current file. +ac_beg=1 # First line for current file. +ac_end=$ac_max_sed_cmds # Line after last line for current file. +ac_more_lines=: +ac_sed_cmds="" +while $ac_more_lines; do + if test $ac_beg -gt 1; then + sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file + else + sed "${ac_end}q" conftest.subs > conftest.s$ac_file + fi + if test ! -s conftest.s$ac_file; then + ac_more_lines=false + rm -f conftest.s$ac_file + else + if test -z "$ac_sed_cmds"; then + ac_sed_cmds="sed -f conftest.s$ac_file" + else + ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file" + fi + ac_file=`expr $ac_file + 1` + ac_beg=$ac_end + ac_end=`expr $ac_end + $ac_max_sed_cmds` + fi +done +if test -z "$ac_sed_cmds"; then + ac_sed_cmds=cat +fi +EOF + +cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF +for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then + # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". + case "$ac_file" in + *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'` + ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; + *) ac_file_in="${ac_file}.in" ;; + esac + + # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories. + + # Remove last slash and all that follows it. Not all systems have dirname. + ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` + if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then + # The file is in a subdirectory. + test ! -d "$ac_dir" && mkdir "$ac_dir" + ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`" + # A "../" for each directory in $ac_dir_suffix. + ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'` + else + ac_dir_suffix= ac_dots= + fi + + case "$ac_given_srcdir" in + .) srcdir=. + if test -z "$ac_dots"; then top_srcdir=. + else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;; + /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;; + *) # Relative path. + srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix" + top_srcdir="$ac_dots$ac_given_srcdir" ;; + esac + + case "$ac_given_INSTALL" in + [/$]*) INSTALL="$ac_given_INSTALL" ;; + *) INSTALL="$ac_dots$ac_given_INSTALL" ;; + esac + + echo creating "$ac_file" + rm -f "$ac_file" + configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure." + case "$ac_file" in + *Makefile*) ac_comsub="1i\\ +# $configure_input" ;; + *) ac_comsub= ;; + esac + + ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"` + sed -e "$ac_comsub +s%@configure_input@%$configure_input%g +s%@srcdir@%$srcdir%g +s%@top_srcdir@%$top_srcdir%g +s%@INSTALL@%$INSTALL%g +" $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file +fi; done +rm -f conftest.s* + +# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where +# NAME is the cpp macro being defined and VALUE is the value it is being given. +# +# ac_d sets the value in "#define NAME VALUE" lines. +ac_dA='s%^\([ ]*\)#\([ ]*define[ ][ ]*\)' +ac_dB='\([ ][ ]*\)[^ ]*%\1#\2' +ac_dC='\3' +ac_dD='%g' +# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE". +ac_uA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' +ac_uB='\([ ]\)%\1#\2define\3' +ac_uC=' ' +ac_uD='\4%g' +# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE". +ac_eA='s%^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' +ac_eB='$%\1#\2define\3' +ac_eC=' ' +ac_eD='%g' + +if test "${CONFIG_HEADERS+set}" != set; then +EOF +cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF +fi +for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then + # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in". + case "$ac_file" in + *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'` + ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; + *) ac_file_in="${ac_file}.in" ;; + esac + + echo creating $ac_file + + rm -f conftest.frag conftest.in conftest.out + ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"` + cat $ac_file_inputs > conftest.in + +EOF + +# Transform confdefs.h into a sed script conftest.vals that substitutes +# the proper values into config.h.in to produce config.h. And first: +# Protect against being on the right side of a sed subst in config.status. +# Protect against being in an unquoted here document in config.status. +rm -f conftest.vals +cat > conftest.hdr <<\EOF +s/[\\&%]/\\&/g +s%[\\$`]%\\&%g +s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp +s%ac_d%ac_u%gp +s%ac_u%ac_e%gp +EOF +sed -n -f conftest.hdr confdefs.h > conftest.vals +rm -f conftest.hdr + +# This sed command replaces #undef with comments. This is necessary, for +# example, in the case of _POSIX_SOURCE, which is predefined and required +# on some systems where configure will not decide to define it. +cat >> conftest.vals <<\EOF +s%^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */% +EOF + +# Break up conftest.vals because some shells have a limit on +# the size of here documents, and old seds have small limits too. + +rm -f conftest.tail +while : +do + ac_lines=`grep -c . conftest.vals` + # grep -c gives empty output for an empty file on some AIX systems. + if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi + # Write a limited-size here document to conftest.frag. + echo ' cat > conftest.frag <> $CONFIG_STATUS + sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS + echo 'CEOF + sed -f conftest.frag conftest.in > conftest.out + rm -f conftest.in + mv conftest.out conftest.in +' >> $CONFIG_STATUS + sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail + rm -f conftest.vals + mv conftest.tail conftest.vals +done +rm -f conftest.vals + +cat >> $CONFIG_STATUS <<\EOF + rm -f conftest.frag conftest.h + echo "/* $ac_file. Generated automatically by configure. */" > conftest.h + cat conftest.in >> conftest.h + rm -f conftest.in + if cmp -s $ac_file conftest.h 2>/dev/null; then + echo "$ac_file is unchanged" + rm -f conftest.h + else + # Remove last slash and all that follows it. Not all systems have dirname. + ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'` + if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then + # The file is in a subdirectory. + test ! -d "$ac_dir" && mkdir "$ac_dir" + fi + rm -f $ac_file + mv conftest.h $ac_file + fi +fi; done + +EOF + +cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF +srcdir=$ac_given_srcdir +while test -n "$ac_sources"; do + set $ac_dests; ac_dest=$1; shift; ac_dests=$* + set $ac_sources; ac_source=$1; shift; ac_sources=$* + + echo "linking $srcdir/$ac_source to $ac_dest" + + if test ! -r $srcdir/$ac_source; then + { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; } + fi + rm -f $ac_dest + + # Make relative symlinks. + # Remove last slash and all that follows it. Not all systems have dirname. + ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'` + if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then + # The dest file is in a subdirectory. + test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir" + ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`" + # A "../" for each directory in $ac_dest_dir_suffix. + ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'` + else + ac_dest_dir_suffix= ac_dots= + fi + + case "$srcdir" in + [/$]*) ac_rel_source="$srcdir/$ac_source" ;; + *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;; + esac + + # Make a symlink if possible; otherwise try a hard link. + if ln -s $ac_rel_source $ac_dest 2>/dev/null || + ln $srcdir/$ac_source $ac_dest; then : + else + { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; } + fi +done +EOF +cat >> $CONFIG_STATUS <> $CONFIG_STATUS <<\EOF +test -z "$CONFIG_HEADERS" || echo timestamp > include/stamp-h +if test -n "$CONFIG_FILES"; then + ac_file=Makefile . ${libgcj_basedir}/../config-ml.in +fi +exit 0 +EOF +chmod +x $CONFIG_STATUS +rm -fr confdefs* $ac_clean_files +test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1 + diff --git a/libjava/configure.host b/libjava/configure.host new file mode 100644 index 00000000000..61e722b5598 --- /dev/null +++ b/libjava/configure.host @@ -0,0 +1,61 @@ +# configure.host + +# This shell script handles all host based configuration for libgcj. +# It sets various shell variables based on the the host and the +# configuration options. You can modify this shell script without +# needing to rerun autoconf. + +# This shell script should be invoked as +# . configure.host +# If it encounters an error, it will exit with a message. + +# It uses the following shell variables: +# host The configuration host +# host_cpu The configuration host CPU +# target_optspace --enable-target-optspace ("yes", "no", "") + +# It sets the following shell variables: +# libgcj_cflags Special CFLAGS to use when building +# libgcj_cxxflags Special CXXFLAGS to use when building +# libgcj_javaflags Special JAVAFLAGS to use when building + +libgcj_flags= +libgcj_cflags= +libgcj_cxxflags= +libgcj_javaflags= + +case "${target_optspace}:${host}" in + yes:*) + libgcj_flags="${libgcj_flags} -Os" + ;; + :m32r-* | :d10v-* | :d30v-*) + libgcj_flags="${libgcj_flags} -Os" + ;; + no:* | :*) + # Nothing. + ;; +esac + +AM_RUNTESTFLAGS= + +# Set any host dependent compiler flags. +# THIS TABLE IS SORTED. KEEP IT THAT WAY. + +echo "$target" + +case "${host}" in + mips-tx39-*|mipstx39-unknown-*) + libgcj_flags="${libgcj_flags} -G 0" + LDFLAGS="$LDFLAGS -Tjmr3904dram.ld" + AM_RUNTESTFLAGS="--target_board=jmr3904-sim" + ;; + i686-*|i586-*) + libgcj_flags="${libgcj_flags} -ffloat-store" + ;; + *) + ;; +esac + +libgcj_cflags="${libgcj_cflags} ${libgcj_flags}" +libgcj_cxxflags="${libgcj_cxxflags} ${libgcj_flags}" +libgcj_javaflags="${libgcj_javaflags} ${libgcj_flags}" diff --git a/libjava/configure.in b/libjava/configure.in new file mode 100644 index 00000000000..98083c9d6da --- /dev/null +++ b/libjava/configure.in @@ -0,0 +1,387 @@ +dnl Process this with autoconf to create configure +AC_INIT(java/lang/System.java) + +dnl Can't be done in LIBGCJ_CONFIGURE because that confuses automake. +AC_CONFIG_AUX_DIR(..) + +AC_CANONICAL_SYSTEM + +dnl We use these options to decide which functions to include. +AC_ARG_WITH(target-subdir, +[ --with-target-subdir=SUBDIR Configuring in a subdirectory]) +AC_ARG_WITH(cross-host, +[ --with-cross-host=HOST Configuring with a cross compiler]) + +LIBGCJ_CONFIGURE(.) + +AM_CONFIG_HEADER(include/config.h) + +if test -z "$with_target_subdir" || test "$with_target_subdir" = "."; then + COMPPATH=. +else + COMPPATH=.. +fi +AC_SUBST(COMPPATH) + +dnl The -no-testsuite modules omit the test subdir. +AM_CONDITIONAL(TESTSUBDIR, test -d $srcdir/testsuite) + +dnl See whether the user prefers size or speed for Character. +dnl The default is size. +AC_ARG_ENABLE(fast-character, +[ --enable-fast-character Prefer speed over size for Character], +# Nothing +, AC_DEFINE(COMPACT_CHARACTER)) + +dnl See if the user has requested runtime debugging. +AC_ARG_ENABLE(libgcj-debug, +[ --enable-libgcj-debug Enable runtime debugging code], + if test "$enable_libgcj_debug" = yes; then + AC_DEFINE(DEBUG) + fi) + +dnl If the target is an eCos system, use the appropriate eCos +dnl I/O routines. +dnl FIXME: this should not be a local option but a global target +dnl system; at present there is no eCos target. +TARGET_ECOS="no" +AC_ARG_WITH(ecos, +[ --with-ecos Enable runtime eCos target support.], +TARGET_ECOS="$with_ecos" +) + +case "$TARGET_ECOS" in + no) + FILE_DESCRIPTOR=natFileDescriptorPosix.cc + ;; + *) + FILE_DESCRIPTOR=natFileDescriptorEcos.cc + AC_DEFINE(ECOS) + ;; +esac + +AC_EGREP_HEADER(__uint32_t, sys/types.h, AC_DEFINE(HAVE_INT32_DEFINED)) +AC_EGREP_HEADER(__uint32_t, sys/config.h, AC_DEFINE(HAVE_INT32_DEFINED)) + +dnl These may not be defined in a non-ANS conformant embedded system. +dnl FIXME: Should these case a runtime exception in that case? +AC_EGREP_HEADER(mktime, time.h, AC_DEFINE(HAVE_MKTIME)) +AC_EGREP_HEADER(localtime, time.h, AC_DEFINE(HAVE_LOCALTIME)) + +dnl Create the subdirectory for natFileDescriptor.cc, or the attempt +dnl to create the link will fail. +test -d java || mkdir java +test -d java/io || mkdir java/io +AC_LINK_FILES(java/io/$FILE_DESCRIPTOR, java/io/natFileDescriptor.cc) + +dnl Allow the GC to be disabled. Can be useful when debugging. +AC_MSG_CHECKING([for garbage collector to use]) +AC_ARG_ENABLE(java-gc, +changequote(<<,>>)dnl +<< --enable-java-gc=TYPE choose garbage collector [boehm]>>, +changequote([,]) + GC=$enableval, + GC=boehm) +GCLIBS= +GCINCS= +GCDEPS= +GCOBJS= +case "$GC" in + boehm) + AC_MSG_RESULT(boehm) + GCLIBS='-L$(top_builddir)/../boehm-gc -lgcjgc' + GCDEPS='$(top_builddir)/../boehm-gc/libgcjgc.a' + GCINCS='-I$(top_srcdir)/../boehm-gc -I$(top_builddir)/../boehm-gc' + dnl We also want to pick up some cpp flags required when including + dnl boehm-config.h. Yuck. + GCINCS="$GCINCS `cat ../boehm-gc/boehm-cflags`" + GCOBJS=boehm.o + GCHDR=boehm-gc.h + dnl The POSIX thread support needs to know this. + AC_DEFINE(HAVE_BOEHM_GC) + ;; + no) + AC_MSG_RESULT(none) + GCOBJS=nogc.o + GCHDR=no-gc.h + ;; + *) + AC_MSG_ERROR(unrecognized collector \"$GC\") + ;; +esac +AC_SUBST(GCLIBS) +AC_SUBST(GCINCS) +AC_SUBST(GCDEPS) +AC_SUBST(GCOBJS) +AC_LINK_FILES(include/$GCHDR, include/java-gc.h) + + +dnl Note that this code is kept in sync with similar code in gcc/configure.in. +dnl In particular both packages must make the same decision about which +dnl thread package to use. +AC_MSG_CHECKING([for threads package to use]) +AC_ARG_ENABLE(threads, [ --enable-threads=TYPE choose threading package], + THREADS=$enableval, + dnl FIXME: figure out native threads to use here. + THREADS=no) + +if test "$THREADS" = yes; then + case "$host" in + *-*-vxworks*) + THREADS=vxworks + ;; + *-*-linux*) + # FIXME: this isn't correct in all cases. + THREADS=posix + ;; + *-*-win*) + THREADS=win32 + ;; + *-*-irix*) + THREADS=irix + ;; + *-*-solaris*) + # FIXME: for now, choose POSIX, because we implement that. + # Later, choose solaris threads. + THREADS=posix + ;; + *) + # For now. + THREADS=none + ;; + esac +fi + +case "$THREADS" in + no | none | single) + THREADS=none + ;; + posix | pthreads) + THREADS=posix + case "$host" in + *-*-linux*) + AC_DEFINE(LINUX_THREADS) + ;; + esac + ;; + qt) + ;; + decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks) + AC_MSG_ERROR(thread package $THREADS not yet supported) + ;; + *) + AC_MSG_ERROR($THREADS is an unknown thread package) + ;; +esac +AC_MSG_RESULT($THREADS) + +THREADLIBS= +THREADINCS= +THREADDEPS= +THREADOBJS= +THREADH= +case "$THREADS" in + posix) + THREADLIBS=-lpthread + THREADOBJS=posix-threads.o + THREADH=posix-threads.h + # MIT pthreads doesn't seem to have the mutexattr functions. + # But for now we don't check for it. We just assume you aren't + # using MIT pthreads. + AC_DEFINE(HAVE_PTHREAD_MUTEXATTR_INIT) + ;; + + qt) + THREADLIBS='-L$(top_builddir)/../qthreads -lgcjcoop' + THREADOBJS=quick-threads.o + THREADINCS='-I$(top_srcdir)/../qthreads' + THREADH=quick-threads.h + THREADDEPS='$(top_builddir)/../qthreads/libgcjcoop.a' + ;; + + none) + THREADOBJS=no-threads.o + THREADH=no-threads.h + ;; +esac +AC_LINK_FILES(include/$THREADH, include/java-threads.h) +AC_SUBST(THREADLIBS) +AC_SUBST(THREADINCS) +AC_SUBST(THREADDEPS) +AC_SUBST(THREADOBJS) + +AM_CONDITIONAL(USING_GCC, test "$GCC" = yes) + +CANADIAN=no +NULL_TARGET=no + +# Find eh-common.h and support headers. If we're in the tree with +# gcc, then look there. Otherwise look in compat-include. If all else +# fails, just hope the user has set things up somehow. +if test -r $srcdir/../gcc/eh-common.h; then + EH_COMMON_INCLUDE='-I$(top_srcdir)/../gcc -I$(top_srcdir)/../include' +else + if test -d $srcdir/../compat-include; then + EH_COMMON_INCLUDE='-I$(top_srcdir)/../compat-include' + else + EH_COMMON_INCLUDE= + fi +fi + +if test -n "${with_cross_host}"; then + # We are being configured with a cross compiler. AC_REPLACE_FUNCS + # may not work correctly, because the compiler may not be able to + # link executables. + + # We assume newlib. This lets us hard-code the functions we know + # we'll have. + AC_DEFINE(HAVE_MEMMOVE) + AC_DEFINE(HAVE_MEMCPY) + AC_DEFINE(HAVE_STRERROR) + AC_DEFINE(HAVE_CTIME_R) + AC_DEFINE(HAVE_GMTIME_R) + AC_DEFINE(HAVE_LOCALTIME_R) + dnl This is only for POSIX threads. + AC_DEFINE(HAVE_PTHREAD_MUTEXATTR_INIT) + dnl We also assume we are using gcc, which provides alloca. + AC_DEFINE(HAVE_ALLOCA) + + # If Canadian cross, then don't pick up tools from the build + # directory. + if test "$build" != "$with_cross_host"; then + CANADIAN=yes + EH_COMMON_INCLUDE= + fi +else + # Some POSIX thread systems don't have pthread_mutexattr_settype. + # E.g., Solaris. + AC_CHECK_FUNCS(strerror ioctl select open fsync sleep) + AC_CHECK_FUNCS(ctime_r ctime, break) + AC_CHECK_FUNCS(gmtime_r localtime_r readdir_r getpwuid_r) + AC_CHECK_FUNCS(access stat mkdir rename rmdir unlink realpath) + AC_CHECK_FUNCS(inet_aton inet_addr, break) + AC_CHECK_FUNCS(inet_pton uname) + + AC_CHECK_FUNCS(gethostbyname_r, [ + AC_DEFINE(HAVE_GETHOSTBYNAME_R) + # There are two different kinds of gethostbyname_r. + # We look for the one that returns `int'. + # Hopefully this check is robust enough. + AC_EGREP_HEADER(int.*gethostbyname_r, netdb.h, [ + AC_DEFINE(GETHOSTBYNAME_R_RETURNS_INT)])]) + + AC_CHECK_FUNCS(gethostbyaddr_r, [ + AC_DEFINE(HAVE_GETHOSTBYADDR_R) + # There are two different kinds of gethostbyaddr_r. + # We look for the one that returns `int'. + # Hopefully this check is robust enough. + AC_EGREP_HEADER(int.*gethostbyaddr_r, netdb.h, [ + AC_DEFINE(GETHOSTBYADDR_R_RETURNS_INT)])]) + + AC_CHECK_FUNCS(gethostname, [ + AC_DEFINE(HAVE_GETHOSTNAME) + AC_EGREP_HEADER(gethostname, unistd.h, [ + AC_DEFINE(HAVE_GETHOSTNAME_DECL)])]) + + # Look for these functions in the thread library. + save_LIBS="$LIBS" + LIBS="$LIBS $THREADLIBS" + AC_CHECK_FUNCS(pthread_mutexattr_settype pthread_mutexattr_setkind_np sched_yield) + LIBS="$save_LIBS" + + # We require a way to get the time. + time_found=no + AC_CHECK_FUNCS(gettimeofday time ftime, time_found=yes) + if test "$time_found" = no; then + AC_MSG_ERROR([no function found to get the time]) + fi + + # We require memmove. + memmove_found=no + AC_CHECK_FUNCS(memmove, memmove_found=yes) + if test "$memmove_found" = no; then + AC_MSG_ERROR([memmove is required]) + fi + + # We require memcpy. + memcpy_found=no + AC_CHECK_FUNCS(memcpy, memcpy_found=yes) + if test "$memcpy_found" = no; then + AC_MSG_ERROR([memcpy is required]) + fi + + test -d "$libgcj_basedir/../gcc/java" || { + CANADIAN=yes + NULL_TARGET=yes + } +fi + +AM_CONDITIONAL(CANADIAN, test "$CANADIAN" = yes) +AM_CONDITIONAL(NULL_TARGET, test "$NULL_TARGET" = yes) +AM_CONDITIONAL(NATIVE, test "$CANADIAN" = no || test "$NULL_TARGET" = yes) + +AC_SUBST(EH_COMMON_INCLUDE) + +AC_SUBST(AM_RUNTESTFLAGS) + +dnl We check for sys/filio.h because Solaris 2.5 defines FIONREAD there. +dnl On that system, sys/ioctl.h will not include sys/filio.h unless +dnl BSD_COMP is defined; just including sys/filio.h is simpler. +AC_CHECK_HEADERS(unistd.h sys/time.h sys/types.h fcntl.h sys/ioctl.h sys/filio.h sys/stat.h sys/select.h sys/socket.h netinet/in.h arpa/inet.h netdb.h pwd.h) +dnl We avoid AC_HEADER_DIRENT since we really only care about dirent.h +dnl for now. If you change this, you also must update natFile.cc. +AC_CHECK_HEADERS(dirent.h) + +AC_MSG_CHECKING([whether struct sockaddr_in6 is in netinet/in.h]) +AC_TRY_COMPILE([#include ], [struct sockaddr_in6 addr6;], + [AC_DEFINE(HAVE_INET6) + AC_MSG_RESULT(yes)], + [AC_MSG_RESULT(no)]) + +AC_MSG_CHECKING([for socklen_t in sys/socket.h]) +AC_TRY_COMPILE([#include ], [socklen_t x = 5;], + [AC_DEFINE(HAVE_SOCKLEN_T) + AC_MSG_RESULT(yes)], + [AC_MSG_RESULT(no)]) + +AC_MSG_CHECKING([for tm_gmtoff in struct tm]) +AC_TRY_COMPILE([#include ], [struct tm tim; tim.tm_gmtoff = 0;], + [AC_DEFINE(STRUCT_TM_HAS_GMTOFF) + AC_MSG_RESULT(yes)], + [AC_MSG_RESULT(no) + AC_MSG_CHECKING([for global timezone variable]) + dnl FIXME: we don't want a link check here because that won't work + dnl when cross-compiling. So instead we make an assumption that + dnl the header file will mention timezone if it exists. + AC_TRY_COMPILE([#include ], [long z2 = timezone;], + [AC_DEFINE(HAVE_TIMEZONE) + AC_MSG_RESULT(yes)], + [AC_MSG_RESULT(no)])]) + +AC_FUNC_ALLOCA + +AC_CHECK_PROGS(PERL, perl, false) + +if test "${multilib}" = "yes"; then + multilib_arg="--enable-multilib" +else + multilib_arg= +fi + +here=`pwd` +AC_SUBST(here) + +AC_OUTPUT(Makefile testsuite/Makefile, +[if test -n "$CONFIG_FILES"; then + ac_file=Makefile . ${libgcj_basedir}/../config-ml.in +fi], +srcdir=${srcdir} +host=${host} +target=${target} +with_multisubdir=${with_multisubdir} +ac_configure_args="${multilib_arg} ${ac_configure_args}" +CONFIG_SHELL=${CONFIG_SHELL-/bin/sh} +libgcj_basedir=${libgcj_basedir} +CC="${CC}" +CXX="${CXX}" +) diff --git a/libjava/doc/cni.sgml b/libjava/doc/cni.sgml new file mode 100644 index 00000000000..02554319508 --- /dev/null +++ b/libjava/doc/cni.sgml @@ -0,0 +1,972 @@ + +
+ +The Cygnus Native Interface for C++/Java Integration +Writing native Java methods in natural C++ + +Cygnus Solutions + +February, 1999 + + + +This documents CNI, the Cygnus Native Interface, +which is is a convenient way to write Java native methods using C++. +This is a more efficient, more convenient, but less portable +alternative to the standard JNI (Java Native Interface). + + +Basic Concepts + +In terms of languages features, Java is mostly a subset +of C++. Java has a few important extensions, plus a powerful standard +class library, but on the whole that does not change the basic similarity. +Java is a hybrid object-oriented language, with a few native types, +in addition to class types. It is class-based, where a class may have +static as well as per-object fields, and static as well as instance methods. +Non-static methods may be virtual, and may be overloaded. Overloading is +resolved at compile time by matching the actual argument types against +the parameter types. Virtual methods are implemented using indirect calls +through a dispatch table (virtual function table). Objects are +allocated on the heap, and initialized using a constructor method. +Classes are organized in a package hierarchy. + + +All of the listed attributes are also true of C++, though C++ has +extra features (for example in C++ objects may be allocated not just +on the heap, but also statically or in a local stack frame). Because +gcj uses the same compiler technology as +g++ (the GNU C++ compiler), it is possible +to make the intersection of the two languages use the same +ABI (object representation and calling conventions). +The key idea in CNI is that Java objects are C++ objects, +and all Java classes are C++ classes (but not the other way around). +So the most important task in integrating Java and C++ is to +remove gratuitous incompatibilities. + + +You write CNI code as a regular C++ source file. (You do have to use +a Java/CNI-aware C++ compiler, specifically a recent version of G++.) + +You start with: + +#include <cni.h> + + + +You then include header files for the various Java classes you need +to use: + +#include <java/lang/Character.h> +#include <java/util/Date.h> +#include <java/lang/IndexOutOfBoundsException.h> + + + +In general, CNI functions and macros start with the +`Jv' prefix, for example the function +`JvNewObjectArray'. This convention is used to +avoid conflicts with other libraries. +Internal functions in CNI start with the prefix +`_Jv_'. You should not call these; +if you find a need to, let us know and we will try to come up with an +alternate solution. (This manual lists _Jv_AllocBytes +as an example; CNI should instead provide +a JvAllocBytes function.) + +These header files are automatically generated by gcjh. + + + +Packages + +The only global names in Java are class names, and packages. +A package can contain zero or more classes, and +also zero or more sub-packages. +Every class belongs to either an unnamed package or a package that +has a hierarchical and globally unique name. + + +A Java package is mapped to a C++ namespace. +The Java class java.lang.String +is in the package java.lang, which is a sub-package +of java. The C++ equivalent is the +class java::lang::String, +which is in the namespace java::lang, +which is in the namespace java. + + +Here is how you could express this: + +// Declare the class(es), possibly in a header file: +namespace java { + namespace lang { + class Object; + class String; + ... + } +} + +class java::lang::String : public java::lang::Object +{ + ... +}; + + + +The gcjh tool automatically generates the +nessary namespace declarations. + +Nested classes as a substitute for namespaces + + +It is not that long since g++ got complete namespace support, +and it was very recent (end of February 1999) that libgcj +was changed to uses namespaces. Releases before then used +nested classes, which are the C++ equivalent of Java inner classes. +They provide similar (though less convenient) functionality. +The old syntax is: + +class java { + class lang { + class Object; + class String; + }; +}; + +The obvious difference is the use of class instead +of namespace. The more important difference is +that all the members of a nested class have to be declared inside +the parent class definition, while namespaces can be defined in +multiple places in the source. This is more convenient, since it +corresponds more closely to how Java packages are defined. +The main difference is in the declarations; the syntax for +using a nested class is the same as with namespaces: + +class java::lang::String : public java::lang::Object +{ ... } + +Note that the generated code (including name mangling) +using nested classes is the same as that using namespaces. + + +Leaving out package names + + +Having to always type the fully-qualified class name is verbose. +It also makes it more difficult to change the package containing a class. +The Java package declaration specifies that the +following class declarations are in the named package, without having +to explicitly name the full package qualifiers. +The package declaration can be followed by zero or +more import declarations, which allows either +a single class or all the classes in a package to be named by a simple +identifier. C++ provides something similar +with the using declaration and directive. + + +A Java simple-type-import declaration: + +import PackageName.TypeName; + +allows using TypeName as a shorthand for +PackageName.TypeName. +The C++ (more-or-less) equivalent is a using-declaration: + +using PackageName::TypeName; + + + +A Java import-on-demand declaration: + +import PackageName.*; + +allows using TypeName as a shorthand for +PackageName.TypeName +The C++ (more-or-less) equivalent is a using-directive: + +using namespace PackageName; + + + + + +Primitive types + +Java provides 8 primitives types: +byte, short, int, +long, float, double, +char, and boolean. +These are the same as the following C++ typedefs +(which are defined by cni.h): +jbyte, jshort, jint, +jlong, jfloat, +jdouble, +jchar, and jboolean. +You should use the C++ typenames +(e.g. jint), +and not the Java types names +(e.g. int), +even if they are the same. +This is because there is no guarantee that the C++ type +int is a 32-bit type, but jint +is guaranteed to be a 32-bit type. + + + + + +Java type +C/C++ typename +Description + + + +byte +jbyte +8-bit signed integer + + +short +jshort +16-bit signed integer + + +int +jint +32-bit signed integer + + +long +jlong +64-bit signed integer + + +float +jfloat +32-bit IEEE floating-point number + + +double +jdouble +64-bit IEEE floating-point number + + +char +jchar +16-bit Unicode character + + +boolean +jboolean +logical (Boolean) values + + +void +void +no value + + + + + + + +JvPrimClass +primtype + +This is a macro whose argument should be the name of a primitive +type, e.g. +byte. +The macro expands to a pointer to the Class object +corresponding to the primitive type. +E.g., +JvPrimClass(void) +has the same value as the Java expression +Void.TYPE (or void.class). + + + + +Objects and Classes +Classes + +All Java classes are derived from java.lang.Object. +C++ does not have a unique rootclass, but we use +a C++ java::lang::Object as the C++ version +of the java.lang.Object Java class. All +other Java classes are mapped into corresponding C++ classes +derived from java::lang::Object. + +Interface inheritance (the implements +keyword) is currently not reflected in the C++ mapping. + +Object references + +We implement a Java object reference as a pointer to the start +of the referenced object. It maps to a C++ pointer. +(We cannot use C++ references for Java references, since +once a C++ reference has been initialized, you cannot change it to +point to another object.) +The null Java reference maps to the NULL +C++ pointer. + + +Note that in some Java implementations an object reference is implemented as +a pointer to a two-word handle. One word of the handle +points to the fields of the object, while the other points +to a method table. Gcj does not use this extra indirection. + + +Object fields + +Each object contains an object header, followed by the instance +fields of the class, in order. The object header consists of +a single pointer to a dispatch or virtual function table. +(There may be extra fields in front of the object, +for example for +memory management, but this is invisible to the application, and +the reference to the object points to the dispatch table pointer.) + + +The fields are laid out in the same order, alignment, and size +as in C++. Specifically, 8-bite and 16-bit native types +(byte, short, char, +and boolean) are not +widened to 32 bits. +Note that the Java VM does extend 8-bit and 16-bit types to 32 bits +when on the VM stack or temporary registers. + +If you include the gcjh-generated header for a +class, you can access fields of Java classes in the natural +way. Given the following Java class: + +public class Int +{ + public int i; + public Integer (int i) { this.i = i; } + public static zero = new Integer(0); +} + +you can write: + +#include <cni.h> +#include <Int.h> +Int* +mult (Int *p, jint k) +{ + if (k == 0) + return Int::zero; // static member access. + return new Int(p->i * k); +} + + + +CNI does not strictly enforce the Java access +specifiers, because Java permissions cannot be directly mapped +into C++ permission. Private Java fields and methods are mapped +to private C++ fields and methods, but other fields and methods +are mapped to public fields and methods. + + + + +Arrays + +While in many ways Java is similar to C and C++, +it is quite different in its treatment of arrays. +C arrays are based on the idea of pointer arithmetic, +which would be incompatible with Java's security requirements. +Java arrays are true objects (array types inherit from +java.lang.Object). An array-valued variable +is one that contains a reference (pointer) to an array object. + + +Referencing a Java array in C++ code is done using the +JArray template, which as defined as follows: + +class __JArray : public java::lang::Object +{ +public: + int length; +}; + +template<class T> +class JArray : public __JArray +{ + T data[0]; +public: + T& operator[](jint i) { return data[i]; } +}; + + + + template<class T> T *elements + JArray<T> &array + + This template function can be used to get a pointer to the + elements of the array. + For instance, you can fetch a pointer + to the integers that make up an int[] like so: + +extern jintArray foo; +jint *intp = elements (foo); + +The name of this function may change in the future. + +There are a number of typedefs which correspond to typedefs from JNI. +Each is the type of an array holding objects of the appropriate type: + +typedef __JArray *jarray; +typedef JArray<jobject> *jobjectArray; +typedef JArray<jboolean> *jbooleanArray; +typedef JArray<jbyte> *jbyteArray; +typedef JArray<jchar> *jcharArray; +typedef JArray<jshort> *jshortArray; +typedef JArray<jint> *jintArray; +typedef JArray<jlong> *jlongArray; +typedef JArray<jfloat> *jfloatArray; +typedef JArray<jdouble> *jdoubleArray; + + + + You can create an array of objects using this function: + + jobjectArray JvNewObjectArray + jint length + jclass klass + jobject init + + Here klass is the type of elements of the array; + init is the initial + value to be put into every slot in the array. + + +For each primitive type there is a function which can be used + to create a new array holding that type. The name of the function + is of the form + `JvNew<Type>Array', + where `<Type>' is the name of + the primitive type, with its initial letter in upper-case. For + instance, `JvNewBooleanArray' can be used to create + a new array of booleans. + Each such function follows this example: + + jbooleanArray JvNewBooleanArray + jint length + + + + + jsize JvGetArrayLength + jarray array + + Returns the length of array. + + +Methods + + +Java methods are mapped directly into C++ methods. +The header files generated by gcjh +include the appropriate method definitions. +Basically, the generated methods have the same names and +corresponding types as the Java methods, +and are called in the natural manner. + +Overloading + +Both Java and C++ provide method overloading, where multiple +methods in a class have the same name, and the correct one is chosen +(at compile time) depending on the argument types. +The rules for choosing the correct method are (as expected) more complicated +in C++ than in Java, but given a set of overloaded methods +generated by gcjh the C++ compiler will choose +the expected one. + +Common assemblers and linkers are not aware of C++ overloading, +so the standard implementation strategy is to encode the +parameter types of a method into its assembly-level name. +This encoding is called mangling, +and the encoded name is the mangled name. +The same mechanism is used to implement Java overloading. +For C++/Java interoperability, it is important that both the Java +and C++ compilers use the same encoding scheme. + + + +Static methods + +Static Java methods are invoked in CNI using the standard +C++ syntax, using the `::' operator rather +than the `.' operator. For example: + + +jint i = java::lang::Math::round((jfloat) 2.3); + + + +Defining a static native method uses standard C++ method +definition syntax. For example: + +#include <java/lang/Integer.h> +java::lang::Integer* +java::lang::Integer::getInteger(jstring str) +{ + ... +} + + + +Object Constructors + +Constructors are called implicitly as part of object allocation +using the new operator. For example: + +java::lang::Int x = new java::lang::Int(234); + + + + +Java does not allow a constructor to be a native method. +Instead, you could define a private method which +you can have the constructor call. + + + +Instance methods + + +Virtual method dispatch is handled essentially the same way +in C++ and Java -- i.e. by doing an +indirect call through a function pointer stored in a per-class virtual +function table. C++ is more complicated because it has to support +multiple inheritance, but this does not effect Java classes. +However, G++ has historically used a different calling convention +that is not compatible with the one used by gcj. +During 1999, G++ will switch to a new ABI that is compatible with +gcj. Some platforms (including Linux) have already +changed. On other platforms, you will have to pass +the -fvtable-thunks flag to g++ when +compiling CNI code. + + +Calling a Java instance method in CNI is done +using the standard C++ syntax. For example: + + java::lang::Number *x; + if (x->doubleValue() > 0.0) ... + + + +Defining a Java native instance method is also done the natural way: + +#include <java/lang/Integer.h> +jdouble +java::lang:Integer::doubleValue() +{ + return (jdouble) value; +} + + + + +Interface method calls + +In Java you can call a method using an interface reference. +This is not yet supported in CNI. + + + +Object allocation + + +New Java objects are allocated using a +class-instance-creation-expression: + +new Type ( arguments ) + +The same syntax is used in C++. The main difference is that +C++ objects have to be explicitly deleted; in Java they are +automatically deleted by the garbage collector. +Using CNI, you can allocate a new object +using standard C++ syntax. The C++ compiler is smart enough to +realize the class is a Java class, and hence it needs to allocate +memory from the garbage collector. If you have overloaded +constructors, the compiler will choose the correct one +using standard C++ overload resolution rules. For example: + +java::util::Hashtable *ht = new java::util::Hashtable(120); + + + + + void *_Jv_AllocBytes + jsize size + + Allocate size bytes. This memory is not + scanned by the garbage collector. However, it will be freed by +the GC if no references to it are discovered. + + + +Interfaces + +A Java class can implement zero or more +interfaces, in addition to inheriting from +a single base class. +An interface is a collection of constants and method specifications; +it is similar to the signatures available +as a G++ extension. An interface provides a subset of the +functionality of C++ abstract virtual base classes, but they +are currently implemented differently. +CNI does not currently provide any support for interfaces, +or calling methods from an interface pointer. +This is partly because we are planning to re-do how +interfaces are implemented in gcj. + + + +Strings + +CNI provides a number of utility functions for +working with Java String objects. +The names and interfaces are analogous to those of JNI. + + + + + jstring JvNewString + const jchar *chars + jsize len + + Creates a new Java String object, where + chars are the contents, and + len is the number of characters. + + + + + jstring JvNewStringLatin1 + const char *bytes + jsize len + + Creates a new Java String object, where bytes + are the Latin-1 encoded + characters, and len is the length of + bytes, in bytes. + + + + + jstring JvNewStringLatin1 + const char *bytes + + Like the first JvNewStringLatin1, but computes len + using strlen. + + + + + jstring JvNewStringUTF + const char *bytes + + Creates a new Java String object, where bytes are + the UTF-8 encoded characters of the string, terminated by a null byte. + + + + + jchar *JvGetStringChars + jstring str + + Returns a pointer to the array of characters which make up a string. + + + + + int JvGetStringUTFLength + jstring str + + Returns number of bytes required to encode contents + of str as UTF-8. + + + + + jsize JvGetStringUTFRegion + jstring str + jsize start + jsize len + char *buf + + This puts the UTF-8 encoding of a region of the + string str into + the buffer buf. + The region of the string to fetch is specifued by + start and len. + It is assumed that buf is big enough + to hold the result. Note + that buf is not null-terminated. + + + +Class Initialization + +Java requires that each class be automatically initialized at the time +of the first active use. Initializing a class involves +initializing the static fields, running code in class initializer +methods, and initializing base classes. There may also be +some implementation specific actions, such as allocating +String objects corresponding to string literals in +the code. + +The Gcj compiler inserts calls to JvInitClass (actually +_Jv_InitClass) at appropriate places to ensure that a +class is initialized when required. The C++ compiler does not +insert these calls automatically - it is the programmer's +responsibility to make sure classes are initialized. However, +this is fairly painless because of the conventions assumed by the Java +system. + +First, libgcj will make sure a class is initialized +before an instance of that object is created. This is one +of the responsibilities of the new operation. This is +taken care of both in Java code, and in C++ code. (When the G++ +compiler sees a new of a Java class, it will call +a routine in libgcj to allocate the object, and that +routine will take care of initializing the class.) It follows that you can +access an instance field, or call an instance (non-static) +method and be safe in the knowledge that the class and all +of its base classes have been initialized. + +Invoking a static method is also safe. This is because the +Java compiler adds code to the start of a static method to make sure +the class is initialized. However, the C++ compiler does not +add this extra code. Hence, if you write a native static method +using CNI, you are responsible for calling JvInitClass +before doing anything else in the method (unless you are sure +it is safe to leave it out). + +Accessing a static field also requires the class of the +field to be initialized. The Java compiler will generate code +to call _Jv_InitClass before getting or setting the field. +However, the C++ compiler will not generate this extra code, +so it is your responsibility to make sure the class is +initialized before you access a static field. + +Exception Handling + +While C++ and Java share a common exception handling framework, +things are not quite as integrated as we would like, yet. +The main issue is the incompatible exception values, +and that the run-time type information facilities of the +two languages are not integrated. + +Basically, this means that you cannot in C++ catch an exception +value (Throwable) thrown from Java code, nor +can you use throw on a Java exception value from C++ code, +and expect to be able to catch it in Java code. +We do intend to change this. + +You can throw a Java exception from C++ code by using +the JvThrow CNI function. + + void JvThrow + jobject obj + + Throws an exception obj, in a way compatible +with the Java exception-handling functions. + The class of obj must be a subclass of + Throwable. + + +Here is an example: + +if (i >= count) + JvThrow (new java::lang::IndexOutOfBoundsException()); + + + + +Synchronization + +Each Java object has an implicit monitor. +The Java VM uses the instruction monitorenter to acquire +and lock a monitor, and monitorexit to release it. +The JNI has corresponding methods MonitorEnter +and MonitorExit. The corresponding CNI macros +are JvMonitorEnter and JvMonitorExit. + + +The Java source language does not provide direct access to these primitives. +Instead, there is a synchronized statement that does an +implicit monitorenter before entry to the block, +and does a monitorexit on exit from the block. +Note that the lock has to be released even the block is abnormally +terminated by an exception, which means there is an implicit +try-finally. + + +From C++, it makes sense to use a destructor to release a lock. +CNI defines the following utility class. + +class JvSynchronize() { + jobject obj; + JvSynchronize(jobject o) { obj = o; JvMonitorEnter(o); } + ~JvSynchronize() { JvMonitorExit(obj); } +}; + +The equivalent of Java's: + +synchronized (OBJ) { CODE; } + +can be simply expressed: + +{ JvSynchronize dummy(OBJ); CODE; } + + + +Java also has methods with the synchronized attribute. +This is equivalent to wrapping the entire method body in a +synchronized statement. +(Alternatively, an implementation could require the caller to do +the synchronization. This is not practical for a compiler, because +each virtual method call would have to test at run-time if +synchronization is needed.) Since in gcj +the synchronized attribute is handled by the +method implementation, it is up to the programmer +of a synchronized native method to handle the synchronization +(in the C++ implementation of the method). +In otherwords, you need to manually add JvSynchronize +in a native synchornized method. + + +Reflection +The types jfieldID and jmethodID +are as in JNI. + +The function JvFromReflectedField, +JvFromReflectedMethod, +JvToReflectedField, and +JvToFromReflectedMethod (as in Java 2 JNI) +will be added shortly, as will other functions corresponding to JNI. + +Using gcjh + + The gcjh is used to generate C++ header files from + Java class files. By default, gcjh generates + a relatively straightforward C++ header file. However, there + are a few caveats to its use, and a few options which can be + used to change how it operates: + + + +--classpath path +--CLASSPATH path +-I dir + + These options can be used to set the class path for gcjh. + Gcjh searches the class path the same way the compiler does; + these options have their familiar meanings. + + + + +-d directory + +Puts the generated .h files +beneath directory. + + + + +-o file + + Sets the name of the .h file to be generated. + By default the .h file is named after the class. + This option only really makes sense if just a single class file + is specified. + + + + +--verbose + + gcjh will print information to stderr as it works. + + + + +-M +-MM +-MD +-MMD + + These options can be used to generate dependency information + for the generated header file. They work the same way as the + corresponding compiler options. + + + + +-prepend text + +This causes the text to be put into the generated + header just after class declarations (but before declaration + of the current class). This option should be used with caution. + + + + +-friend text + +This causes the text to be put into the class +declaration after a friend keyword. +This can be used to declare some + other class or function to be a friend of this class. + This option should be used with caution. + + + + +-add text + +The text is inserted into the class declaration. +This option should be used with caution. + + + + +-append text + +The text is inserted into the header file +after the class declaration. One use for this is to generate +inline functions. This option should be used with caution. + + + + +All other options not beginning with a - are treated +as the names of classes for which headers should be generated. + +gcjh will generate all the required namespace declarations and +#include's for the header file. +In some situations, gcjh will generate simple inline member functions. + +There are a few cases where gcjh will fail to work properly: + +gcjh assumes that all the methods and fields of a class have ASCII +names. The C++ compiler cannot correctly handle non-ASCII +identifiers. gcjh does not currently diagnose this problem. + +gcjh also cannot fully handle classes where a field and a method have +the same name. If the field is static, an error will result. +Otherwise, the field will be renamed in the generated header; `__' +will be appended to the field name. + +Eventually we hope to change the C++ compiler so that these +restrictions can be lifted. + + +
diff --git a/libjava/exception.cc b/libjava/exception.cc new file mode 100644 index 00000000000..644f80b8b0f --- /dev/null +++ b/libjava/exception.cc @@ -0,0 +1,155 @@ +// Functions for Exception Support for Java. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include "exception" +#include + +#include +#include +#include +#include + +// eh-common.h needs gansidecl.h. +#include "gansidecl.h" +#include "eh-common.h" + +typedef struct { + __eh_info eh_info; + void *value; +} java_eh_info; + + +/* Language-specific EH info pointer, throw routine, and language/version + info routines. All defined in libgcc2. */ + +extern "C" java_eh_info **__get_eh_info (); +extern "C" void __throw () __attribute__ ((__noreturn__)); +extern "C" short __get_eh_table_version (void *table); +extern "C" short __get_eh_table_language (void *table); + + +extern "C" void * malloc (size_t); +extern "C" void free (void *); + + +extern "C" void * +_Jv_type_matcher (java_eh_info *info, void* match_info, + void *exception_table) +{ + if (__get_eh_table_language (exception_table) != EH_LANG_Java) + return NULL; + + /* we don't worry about version info yet, there is only one version! */ + + if (match_info != NULL) + { + // The match_info is either a (java::lang::Class*) or + // match_info is one more than a (Utf8Const*). + if (sizeof(void*) != sizeof(size_t)) + abort(); + size_t mi = (size_t) match_info; + if ((mi & 1) != 0) + match_info = _Jv_FindClass ((Utf8Const*) (mi - 1), NULL); + if (! _Jv_IsInstanceOf ((jobject) info->value, (jclass) match_info)) + return NULL; + } + + return info->value; +} + +/* Compiler hook to return a pointer to java exception object. The value + is cleared, so if the exception needs to be rethrown, it should be set + again */ + +extern "C" void * +_Jv_exception_info (void) +{ + java_eh_info *info = *(__get_eh_info ()); + void *ptr; + + if (info == NULL) + abort (); + + ptr = info->value; + + /* clear the value so another throw is an error */ + info->value = NULL; + + return ptr; +} + + + +/* Allocate an exception info structure for java. Called the first time + an exception is thrown. */ + +extern "C" void +_Jv_eh_alloc () +{ + /* FIXME: we should use _Jv_AllocBytes here. However, libgcc2 + apparently can sometimes free() this value itself. */ + java_eh_info *p = (java_eh_info *) malloc (sizeof (java_eh_info)); + if (p == 0) + terminate (); + + p->value = 0; + java_eh_info ** info_ptr = __get_eh_info (); + + /* There should NOT be an exception info pointer already. */ + if (*info_ptr != NULL) + abort (); + + *info_ptr = p; +} + +/* Deallocate the current exception info structure. Called at shutdown time. */ + +extern "C" void +_Jv_eh_free () +{ + java_eh_info ** info_ptr = __get_eh_info (); + if (*info_ptr == NULL) + abort (); + + /* FIXME: ideally we should just let the GC handle this. */ + free (*info_ptr); + *info_ptr = NULL; +} + +/* Perform a throw, Java style. Throw will unwind through this call, so + there better not be any handlers or exception thrown here. */ + + +/* Initialize an __eh_info structure with this libraries matching info. */ + +extern "C" void +_Jv_setup_eh_info (__eh_info *) +{ +} + +extern "C" void +_Jv_Throw (void *value) +{ + if (value == NULL) + value = (void *) new java::lang::NullPointerException (); + java_eh_info *ehinfo = *(__get_eh_info ()); + if (ehinfo == NULL) + { + _Jv_eh_alloc (); + ehinfo = *(__get_eh_info ()); + } + ehinfo->eh_info.match_function = _Jv_type_matcher; + ehinfo->eh_info.language = EH_LANG_Java; + ehinfo->eh_info.version = 1; + ehinfo->value = value; + __throw(); +} diff --git a/libjava/gnu/gcj/convert/BytesToUnicode.java b/libjava/gnu/gcj/convert/BytesToUnicode.java new file mode 100644 index 00000000000..21c1e7e6230 --- /dev/null +++ b/libjava/gnu/gcj/convert/BytesToUnicode.java @@ -0,0 +1,105 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.convert; + +public abstract class BytesToUnicode +{ + /** Buffer to read bytes from. + * The characters inbuffer[inpos] ... inbuffer[inlength-1] are available. */ + public byte[] inbuffer; + /** Starting index in buffer to read bytes from. */ + public int inpos; + /** End of valid bytes in buffer. */ + public int inlength; + + static Class defaultDecodingClass; + + static synchronized void getDefaultDecodingClass() + { + // Test (defaultDecodingClass == null) again in case of race condition. + if (defaultDecodingClass == null) + { + String encoding = System.getProperty("file.encoding"); + String className = "gnu.gcj.convert.Input_"+encoding; + try + { + defaultDecodingClass = Class.forName(className); + } + catch (ClassNotFoundException ex) + { + throw new NoClassDefFoundError("missing default encoding " + + encoding + " (class " + + className + " not found)"); + } + } + } + + public abstract String getName(); + + public static BytesToUnicode getDefaultDecoder() + { + try + { + if (defaultDecodingClass == null) + getDefaultDecodingClass(); + return (BytesToUnicode) defaultDecodingClass.newInstance(); + } + catch (Throwable ex) + { + return new Input_8859_1(); + } + } + + /** Get a byte-stream->char-stream converter given an encoding name. */ + public static BytesToUnicode getDecoder (String encoding) + throws java.io.UnsupportedEncodingException + { + String className = "gnu.gcj.convert.Input_"+encoding; + Class decodingClass; + try + { + decodingClass = Class.forName(className); + return (BytesToUnicode) decodingClass.newInstance(); + } + catch (Throwable ex) + { + throw new java.io.UnsupportedEncodingException(encoding + + " (" + ex + ')'); + } + } + + /** Make input bytes available to the conversion. + * @param buffer source of input bytes + * @param pos index of first available byte + * @param length one more than index of last available byte + */ + public final void setInput(byte[] buffer, int pos, int length) + { + inbuffer = buffer; + inpos = pos; + inlength = length; + } + + /** Convert bytes to chars. + * Input bytes are taken from this.inbuffer. The available input + * bytes start at inbuffer[inpos], and end at inbuffer[inlength-1]. + * @param outbuffer buffer for the converted character + * @param outpos position in buffer to start putting converted characters + * @param outlength the maximum number of characters to read + * @return number of chars placed in outbuffer. + * Also, this.inpos is incremented by the number of bytes consumed. + * + * (Note the asymmetry in that the input upper bound is inbuffer[inlength-1], + * while the output upper bound is outbuffer[outpos+outlength-1]. The + * justification is that inlength is like the count field of a + * BufferedInputStream, while the outlength parameter is like the + * length parameter of a read request.) + */ + public abstract int read (char[] outbuffer, int outpos, int outlength); +} diff --git a/libjava/gnu/gcj/convert/Convert.java b/libjava/gnu/gcj/convert/Convert.java new file mode 100644 index 00000000000..4cdc1152654 --- /dev/null +++ b/libjava/gnu/gcj/convert/Convert.java @@ -0,0 +1,151 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.convert; +import java.io.*; + +public class Convert +{ + static void error (String message) + { + System.err.print("convert: "); + System.err.println(message); + System.err.println("Usage: convert [--from srcEncoding] [--to dstEncoding]"); + System.err.println(" [inputfile [outputfile]]"); + System.exit(-1); + } + + static void missing (String arg) + { + error("missing arg after `" + arg + "' option"); + } + + public static void main (String[] args) + { + String inName = "-"; + String outName = "-"; + String inEncodingName = null; + String outEncodingName = "JavaSrc"; + int seenNames = 0; + boolean reverse = false; + + for (int i = 0; i < args.length; i++) + { + String arg = args[i]; + if (arg.length() == 0) + error("zero-length argument"); + if (arg.charAt(0) == '-') + { + if (arg.equals("-encoding") || arg.equals("--encoding") + || args.equals("-from") || arg.equals("--from")) + { + if (++i == args.length) missing(arg); + inEncodingName = args[i]; + } + else if (arg.equals("-to") || arg.equals("--to")) + { + if (++i == args.length) missing(arg); + outEncodingName = args[i]; + } + else if (arg.equals("-i")) + { + if (++i == args.length) missing(arg); + inName = args[i]; + } + else if (arg.equals("-o")) + { + if (++i == args.length) missing(arg); + outName = args[i]; + } + else if (arg.equals("-reverse") || arg.equals("--reverse")) + { + reverse = true; + } + else if (arg.equals("-")) + { + switch (seenNames) + { + case 0: + inName = "-"; + seenNames++; + break; + case 1: + outName = "-"; + seenNames++; + break; + default: + error("too many `-' arguments"); + } + } + else + error("unrecognized argument `" + arg + "'"); + } + else + { + switch (seenNames) + { + case 0: + inName = arg; + seenNames++; + break; + case 1: + outName = arg; + seenNames++; + break; + default: + error("too many filename arguments"); + } + } + } + + if (reverse) + { + String tmp = inEncodingName; + inEncodingName = outEncodingName; + outEncodingName = tmp; + } + + try + { + BytesToUnicode inDecoder + = inEncodingName == null ? BytesToUnicode.getDefaultDecoder() + : BytesToUnicode.getDecoder(inEncodingName); + UnicodeToBytes outEncoder + = outEncodingName == null ? UnicodeToBytes.getDefaultEncoder() + : UnicodeToBytes.getEncoder(outEncodingName); + InputStream inStream = inName == "-" ? System.in + : new FileInputStream(inName); + OutputStream outStream; + if (outName == "-") + outStream = System.out; + else + outStream = new FileOutputStream(outName); + InputStreamReader in + = new InputStreamReader(inStream, inEncodingName); + OutputStreamWriter out + = new OutputStreamWriter(outStream, outEncodingName); + char[] buffer = new char[2048]; + for (;;) + { + int count = in.read(buffer); + if (count < 0) + break; + out.write(buffer, 0, count); + } + + in.close(); + out.close(); + } + catch (java.io.IOException ex) + { + System.err.print("convert exception: "); + System.err.println(ex); + System.exit(-1); + } + } +} diff --git a/libjava/gnu/gcj/convert/Input_8859_1.java b/libjava/gnu/gcj/convert/Input_8859_1.java new file mode 100644 index 00000000000..262099a13aa --- /dev/null +++ b/libjava/gnu/gcj/convert/Input_8859_1.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.convert; + +public class Input_8859_1 extends BytesToUnicode +{ + public String getName() { return "8859_1"; } + + public int read (char[] outbuffer, int outpos, int outlength) + { + int origpos = outpos; + // Make sure fields of this are in registers. + int inpos = this.inpos; + byte[] inbuffer = this.inbuffer; + int inavail = this.inlength - inpos; + int outavail = outlength - outpos; + if (outavail > inavail) + outavail = inavail; + while (--outavail >= 0) + { + outbuffer[outpos++] = (char) (inbuffer[inpos++] & 0xFF); + } + this.inpos = inpos; + return outpos - origpos; + } +} diff --git a/libjava/gnu/gcj/convert/Input_EUCJIS.java b/libjava/gnu/gcj/convert/Input_EUCJIS.java new file mode 100644 index 00000000000..ecc0fdb9bb8 --- /dev/null +++ b/libjava/gnu/gcj/convert/Input_EUCJIS.java @@ -0,0 +1,19 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.convert; + +public class Input_EUCJIS extends BytesToUnicode +{ + public String getName() { return "EUCJIS"; } + + int codeset = 0; + int first_byte; + + public native int read (char[] outbuffer, int outpos, int outlength); +} diff --git a/libjava/gnu/gcj/convert/Input_UTF8.java b/libjava/gnu/gcj/convert/Input_UTF8.java new file mode 100644 index 00000000000..c706a5259a7 --- /dev/null +++ b/libjava/gnu/gcj/convert/Input_UTF8.java @@ -0,0 +1,107 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.convert; + +public class Input_UTF8 extends BytesToUnicode +{ + public String getName() { return "UTF8"; } + + int partial = 0; + int partial_bytes_expected = 0; + //int suggogate_second = -1; + + public int read (char[] outbuffer, int outpos, int outlength) + { + int origpos = outpos; + for (;;) + { + if (outpos >= outlength) + break; + if (inpos >= inlength) + break; + int b = inbuffer[inpos++]; + if (b >= 0) + outbuffer[outpos++] = (char) b; + else + { + if ((b & 0xC0) == 0x80) // Continuation byte + { + partial = (partial << 6) | (b & 0x3F); + --partial_bytes_expected; + if (partial_bytes_expected == 1) + { + if (partial > (0xFFFF>>6)) + { + // The next continuation byte will cause the result + // to exceed 0xFFFF, so we must use a surrogate pair. + // The "Unicode scalar value" (see D28 in section 3.7 + // of the Unicode Standard 2.0) is defined as: + // value == (hi-0xD800)*0x400+(lo-0xDC00)+0x10000, + // where (hi, lo) is the Unicode surrogate pair. + // After reading the first three bytes, we have: + // partial == (value >> 6). + // Substituting and simplifying, we get: + // partial == (hi-0xD800)*0x10+((lo-0xDC00)>>6)+0x400. + // The definition lo>=0xDC00 && lo<=0xDFFF implies + // that (lo-0xDC00)>>6 is in the range 0..15. + // Hence we can infer (partial-0x400)>>4 == (hi-0xDB00) + // and we can emit the high-surrogate without waiting + // for the final byte: + outbuffer[outpos++] = (char) (0xDA00+(partial>>4)); + + // Now we want to set it up so that when we read + // the final byte on the next iteration, we will + // get the low-surrogate without special handling. + // I.e. we want: + // lo == (next_partial << 6) | (next & 0x3F) + // where next is the next input byte and next_partial + // is the value of partial at the end of this + // iteration. This implies: next_partial == lo >> 6. + // We can simplify the previous: + // partial == (hi-0xD800)*0x10+((lo-0xDC00)>>6)+0x400, + // to: partial == (hi-0xD800)*0x10+(lo>>6)+0x90. + // Inserting the values of hi and next_partial, + // and simplifying, we get: partial == + // ( (partial-0x400)&~0xF) + next_partial + 0x90. + // Solving for next_partial, we get: + // next_partial = partial+0x400-0x90-(partial&~0xF): + // or: next_partial = (partial&0xF) + 0x370. Hence: + partial = (partial & 0xF) + 0x370; + } + } + else if (partial_bytes_expected == 0) + { + outbuffer[outpos++] = (char) partial; + partial = 0; + partial_bytes_expected = 0; + } + } + else // prefix byte + { + if ((b & 0xE) == 0xC0) + { + partial = b & 0x1F; + partial_bytes_expected = 1; + } + else if ((b & 0xF) == 0xF0) + { + partial = b & 0xF; + partial_bytes_expected = 2; + } + else + { + partial = b & 7; + partial_bytes_expected = 3; + } + } + } + } + return outpos - origpos; + } +} diff --git a/libjava/gnu/gcj/convert/JIS0208.h b/libjava/gnu/gcj/convert/JIS0208.h new file mode 100644 index 00000000000..204348f8d77 --- /dev/null +++ b/libjava/gnu/gcj/convert/JIS0208.h @@ -0,0 +1,6880 @@ +/* This file is autoamtically generated from Unicode tables */ +MAP(0x21, 0x21, 0x3000) /* IDEOGRAPHIC SPAC */ +MAP(0x21, 0x22, 0x3001) /* IDEOGRAPHIC COMM */ +MAP(0x21, 0x23, 0x3002) /* IDEOGRAPHIC FULL STO */ +MAP(0x21, 0x24, 0xFF0C) /* FULLWIDTH COMM */ +MAP(0x21, 0x25, 0xFF0E) /* FULLWIDTH FULL STO */ +MAP(0x21, 0x26, 0x30FB) /* KATAKANA MIDDLE DO */ +MAP(0x21, 0x27, 0xFF1A) /* FULLWIDTH COLO */ +MAP(0x21, 0x28, 0xFF1B) /* FULLWIDTH SEMICOLO */ +MAP(0x21, 0x29, 0xFF1F) /* FULLWIDTH QUESTION MAR */ +MAP(0x21, 0x2A, 0xFF01) /* FULLWIDTH EXCLAMATION MAR */ +MAP(0x21, 0x2B, 0x309B) /* KATAKANA-HIRAGANA VOICED SOUND MAR */ +MAP(0x21, 0x2C, 0x309C) /* KATAKANA-HIRAGANA SEMI-VOICED SOUND MAR */ +MAP(0x21, 0x2D, 0x00B4) /* ACUTE ACCEN */ +MAP(0x21, 0x2E, 0xFF40) /* FULLWIDTH GRAVE ACCEN */ +MAP(0x21, 0x2F, 0x00A8) /* DIAERESI */ +MAP(0x21, 0x30, 0xFF3E) /* FULLWIDTH CIRCUMFLEX ACCEN */ +MAP(0x21, 0x31, 0xFFE3) /* FULLWIDTH MACRO */ +MAP(0x21, 0x32, 0xFF3F) /* FULLWIDTH LOW LIN */ +MAP(0x21, 0x33, 0x30FD) /* KATAKANA ITERATION MAR */ +MAP(0x21, 0x34, 0x30FE) /* KATAKANA VOICED ITERATION MAR */ +MAP(0x21, 0x35, 0x309D) /* HIRAGANA ITERATION MAR */ +MAP(0x21, 0x36, 0x309E) /* HIRAGANA VOICED ITERATION MAR */ +MAP(0x21, 0x37, 0x3003) /* DITTO MAR */ +MAP(0x21, 0x38, 0x4EDD) /* avail) + inlength = avail; + for (int i = inlength; --i >= 0; ) + { + buf[count++] = (byte) inbuffer[inpos++]; + } + this.count = count; + return inlength; + } +} diff --git a/libjava/gnu/gcj/convert/Output_JavaSrc.java b/libjava/gnu/gcj/convert/Output_JavaSrc.java new file mode 100644 index 00000000000..aa233612cd7 --- /dev/null +++ b/libjava/gnu/gcj/convert/Output_JavaSrc.java @@ -0,0 +1,82 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.convert; + +/** Convert Unicode to Ascii with \ u XXXX-escapes. */ + +public class Output_JavaSrc extends UnicodeToBytes +{ + public String getName() { return "JavaSrc"; } + + // Number of bytes remaining before pending_char has been written. + int todo; + int pending_char; + + public int write (char[] inbuffer, int inpos, int inlength) + { + int start_pos = inpos; + int avail = buf.length - count; + for (;;) + { + if (avail == 0) + break; + switch (todo) + { + case 1: + if (pending_char == '\\') + { + buf[count++] = (byte) '\\'; + avail--; + todo = 0; + continue; + } + /* ... else fall through ... */ + case 2: + case 3: + case 4: + todo--; + int digit = ((int) pending_char >> (todo * 4)) & 0xF; + buf[count++] = (byte) Character.forDigit(digit, 16); + avail--; + continue; + case 5: + buf[count++] = (byte) 'u'; + avail--; + todo = 4; + continue; + default: + ; + } + if (inlength == 0) + break; + char ch = inbuffer[inpos++]; + inlength--; + if (ch == '\\') + { + buf[count++] = (byte) '\\'; + pending_char = ch; + todo = 1; + avail--; + } + else if (ch < 127) + { + buf[count++] = (byte) ch; + avail--; + } + else + { + buf[count++] = (byte) '\\'; + pending_char = ch; + todo = 5; + avail--; + } + } + return inpos - start_pos; + } +} diff --git a/libjava/gnu/gcj/convert/Output_UTF8.java b/libjava/gnu/gcj/convert/Output_UTF8.java new file mode 100644 index 00000000000..6be753bf8ec --- /dev/null +++ b/libjava/gnu/gcj/convert/Output_UTF8.java @@ -0,0 +1,108 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.convert; + +public class Output_UTF8 extends UnicodeToBytes +{ + public String getName() { return "UTF8"; } + + /** True if a surrogate pair should be emitted as a single UTF8 sequence. + * Otherwise, a surrogate pair is treated as two separate characters. + * Also, '\0' is emitted as {0} if true, and as {0xC0,0x80} if false. */ + public boolean standardUTF8; + + // Saves the previous char if it was a high-surrogate. + char hi_part; + // Value of imcomplete character. + int value; + // Number of continuation bytes still to emit. + int bytes_todo; + + public int write (char[] inbuffer, int inpos, int inlength) + { + int start_pos = inpos; + int avail = buf.length - count; + for (;;) + { + if (inlength == 0 || avail == 0) + break; + // The algororith is made more complicated because we want to write + // at least one byte in the output buffer, if there is room for + // that byte, and at least one input character is available. + // This makes the code more robust, since client code will + // always "make progress", even in the complicated cases, + // where the output buffer only has room for only *part* of a + // multi-byte sequence, or the input char buffer only has half + // of a surrogate pair (when standardUTF8 is set), or both. + + // Handle continuation characters we did not have room for before. + if (bytes_todo > 0) + { + do + { + bytes_todo--; + buf[count++] = (byte) + (((value >> (bytes_todo * 6)) & 0xC0) | 0x80); + avail--; + } + while (bytes_todo > 0 && avail > 0); + continue; + } + char ch = inbuffer[inpos++]; + inlength--; + if (ch < 128 && (ch != 0 || standardUTF8)) + { + avail--; + buf[count++] = (byte) ch; + } + else if (ch <= 0x07FF) + { + buf[count++] = (byte) (0xC0 | (ch >> 6)); + if (--avail > 0) + { + buf[count++] = (byte) ((ch & 0x3F) | 0x80); + avail--; + } + else + { + value = ch; + bytes_todo = 1; + break; + } + } + else if (ch >= 0xD800 && ch <= 0xDFFF && standardUTF8) + { + if (ch <= 0xDBFF) // High surrogates + { + // The first byte is (0xF0 | value>>18), where value is the + // Unicode scalar value of the combine character - which + // we may not know yet. But from substituting: + // value == (hi-0xD800)*0x400+(lo-0xDC00)+0x10000, + // hi==ch, and cancelling we get: + buf[count++] = (byte) (0xF0 | ((ch-0xD800) >> 8)); + avail--; + hi_part = ch; + } + else // Low surrogates + { + value = (hi_part - 0xD800) * 0x400 + (ch - 0xDC00) + 0x10000; + bytes_todo = 3; + } + } + else + { + buf[count++] = (byte) (0xE0 | (ch >> 12)); + value = ch; + avail--; + bytes_todo = 2; + } + } + return inpos - start_pos; + } +} diff --git a/libjava/gnu/gcj/convert/UnicodeToBytes.java b/libjava/gnu/gcj/convert/UnicodeToBytes.java new file mode 100644 index 00000000000..4b772f96eda --- /dev/null +++ b/libjava/gnu/gcj/convert/UnicodeToBytes.java @@ -0,0 +1,90 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.convert; + +public abstract class UnicodeToBytes +{ + /** Buffer to emit bytes to. + * The locations buf[count] ... buf[buf.length-1] are available. */ + public byte[] buf; + public int count; + + static Class defaultEncodingClass; + + static synchronized void getDefaultEncodingClass() + { + // Test (defaultEncodingClass == null) again in case of race condition. + if (defaultEncodingClass == null) + { + String encoding = System.getProperty("file.encoding"); + String className = "gnu.gcj.convert.Output_"+encoding; + try + { + defaultEncodingClass = Class.forName(className); + } + catch (ClassNotFoundException ex) + { + throw new NoClassDefFoundError("missing default encoding " + + encoding + " (class " + + className + " not found)"); + + } + } + } + + public abstract String getName(); + + public static UnicodeToBytes getDefaultEncoder() + { + try + { + if (defaultEncodingClass == null) + getDefaultEncodingClass(); + return (UnicodeToBytes) defaultEncodingClass.newInstance(); + } + catch (Throwable ex) + { + return new Output_8859_1(); + } + } + + /** Get a char-stream->byte-stream converter given an encoding name. */ + public static UnicodeToBytes getEncoder (String encoding) + throws java.io.UnsupportedEncodingException + { + String className = "gnu.gcj.convert.Output_"+encoding; + Class encodingClass; + try + { + encodingClass = Class.forName(className); + return (UnicodeToBytes) encodingClass.newInstance(); + } + catch (Throwable ex) + { + throw new java.io.UnsupportedEncodingException(encoding + " (" + + ex + ')'); + } + } + + public final void setOutput(byte[] buffer, int count) + { + this.buf = buffer; + this.count = count; + } + + /** Convert chars to bytes. + * Converted bytes are written to buf, starting at count. + * @param inbuffer sources of characters to convert + * @param inpos index of initial character ininbuffer to convert + * @param inlength number of characters to convert + * @return number of chars converted + * Also, this.count is increment by the number of bytes converted. + */ + public abstract int write (char[] inbuffer, int inpos, int inlength); +} diff --git a/libjava/gnu/gcj/convert/gen-from-JIS.c b/libjava/gnu/gcj/convert/gen-from-JIS.c new file mode 100644 index 00000000000..c49b8945ec3 --- /dev/null +++ b/libjava/gnu/gcj/convert/gen-from-JIS.c @@ -0,0 +1,154 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include +struct chval +{ + unsigned char b1; /* 1st byte */ + unsigned char b2; /* 2nd byte */ + unsigned short uc; /* unicode value */ +}; + +#define MAP(B1, B2, C) { B1, B2, C }, + +struct chval chtab_0208[] = { +#include "JIS0208.h" + { 255, 255, 0} +}; + +struct chval chtab_0212[] = { +#include "JIS0212.h" + { 255, 255, 0} +}; +#undef MAP + +struct chval sorted[] = { +#define MAP(B1, B2, C) { B1, B2, C }, +#include "JIS0208.h" +#undef MAP +#define MAP(B1, B2, C) { 0x80|B1, B2, C }, +#include "JIS0212.h" +#undef MAP +}; + +struct chval *chtab; + +int +compare (void *p1, void *p2) +{ + struct chval *c1 = (struct chval *) p1; + struct chval *c2 = (struct chval *) p2; + return (int) c1->uc - (int) c2->uc; +} + +int +main(int argc, char** argv) +{ + FILE *out = stdout; + unsigned min1 = 256, max1 = 0, min2 = 256, max2 = 0, count = 0; + unsigned short low1_uc = 0xFFFF, high1_uc = 0; + unsigned short low2_uc = 0xFFFF, high2_uc = 0; + int i; int row, col; + if (strcmp (argv[1], "JIS0208") == 0) + chtab = chtab_0208; + else if (strcmp (argv[1], "JIS0212") == 0) + chtab = chtab_0212; + else if (strcmp (argv[1], "toJIS") == 0) + { + int i; + int count = sizeof(sorted)/sizeof(struct chval); + qsort (sorted, count, sizeof(struct chval), + compare); + for (i = 0; i < count; i++) + { + fprintf (out, " 0x%04x -> 0x%02x, 0x%02x\n", + sorted[i].uc, sorted[i].b1, sorted[i].b2); + } + exit(0); + } + else + { + fprintf (stderr, "bad argument!"); + exit (-1); + } + for (i = 0; chtab[i].b1 != 255; i++) + { + if (chtab[i].b1 < min1) min1 = chtab[i].b1; + if (chtab[i].b2 < min2) min2 = chtab[i].b2; + if (chtab[i].b1 > max1) max1 = chtab[i].b1; + if (chtab[i].b2 > max2) max2 = chtab[i].b2; + count++; + } + fprintf(stderr, "1st byte ranges from %d to %d.\n", min1, max1); + fprintf(stderr, "2nd byte ranges from %d to %d.\n", min2, max2); + + fprintf(out,"/* This file is automatically generated from %s.TXT. */\n", + argv[1]); + fprintf(out, "unsigned short %s_to_Unicode[%d][%d] = {\n", + argv[1], max1 - min1 + 1, max2 - min2 + 1); + i = 0; + for (row = min1; row <= max1; row++) + { + fprintf(out, "/* 1st byte: %d */ { ", row); + if (row < chtab[i].b1) + { + fprintf(out, "0 }, /* unused row */\n"); + } + else if (row > chtab[i].b1) + { + fprintf (stderr, "error - char table out of order!\n"); + exit (-1); + } + else + { + fprintf(out, "\n"); + for (col = min2; col <= max2; col++) + { + if (row == chtab[i].b1 && col == chtab[i].b2) + { + unsigned uc = chtab[i].uc; + if (uc < 0x2000) + { + if (uc > high1_uc) + high1_uc = uc; + if (uc < low1_uc) + low1_uc = uc; + } + else + { + if (uc > high2_uc) + high2_uc = uc; + if (uc < low2_uc) + low2_uc = uc; + } + fprintf (out, " /* 2nd byte: %d */ 0x%04x", + chtab[i].b2, uc); + i++; + } + else if (row < chtab[i].b1 + || (row == chtab[i].b1 && col < chtab[i].b2)) + { + fprintf (out, " 0"); + } + else + { + fprintf (stderr, "error - char table our of order!\n"); + exit (-1); + } + if (col != max2) + fprintf (out, ",\n"); + } + fprintf(out, row == max1 ? "}\n" : "},\n"); + } + } + fprintf(out, "};\n"); + fprintf(stderr, "total number of characters is %d.\n", count); + fprintf(stderr, "Range is 0x%04x-0x%04x and 0x%04x-0x%04x.\n", + low1_uc, high1_uc, low2_uc, high2_uc); + return 0; +} diff --git a/libjava/gnu/gcj/convert/natInput_EUCJIS.cc b/libjava/gnu/gcj/convert/natInput_EUCJIS.cc new file mode 100644 index 00000000000..68e4caed2c0 --- /dev/null +++ b/libjava/gnu/gcj/convert/natInput_EUCJIS.cc @@ -0,0 +1,101 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include +#include +#include + +#define ERROR_CHAR 0xFFFD + +extern unsigned short JIS0208_to_Unicode[84][94]; +extern unsigned short JIS0212_to_Unicode[76][94]; + +jint +gnu::gcj::convert::Input_EUCJIS::read(jcharArray outbuffer, jint outpos, + jint outlength) +{ + jint start_outpos = outpos; + for (;;) + { + if (outpos >= outlength) + break; + if (inpos >= inlength) + break; + int b = ((unsigned char*) elements(inbuffer))[inpos++]; + if (codeset == 0) // ASCII or JIS-Roman + { + if (b < 128) + { +#if 0 + // Technically, we should translate 0x5c to Yen symbol; + // in practice, it is not clear. + if (b == 0x5c) + b = 0x00A5; // Yen sign. +#endif + elements(outbuffer)[outpos++] = (char) b; + } + else + { + if (b == 0x8E) // SS2 + codeset = 2; + else if (b == 0x8F) // SS3 + codeset = 3; + else + { + codeset = 1; + first_byte = b; + } + } + } + else if (codeset == 1) // JIS X 0208:1997 + { + first_byte -= 0x80 + 33; + b -= 0x80 + 33; + if ((unsigned) first_byte >= 84 || (unsigned) b >= 94) + b = ERROR_CHAR; + else + { + b = JIS0208_to_Unicode[first_byte][b]; + if (b == 0) + b = ERROR_CHAR; + } + elements(outbuffer)[outpos++] = b; + codeset = 0; + } + else if (codeset == 2) // Half-width katakana + { + if (b >= 0xA1 && b <= 0xDF) + b += 0xFF61 - 0xA1; + else + b = ERROR_CHAR; + elements(outbuffer)[outpos++] = b; + codeset = 0; + } + else if (codeset == 3) // second byte of JIS X 0212-1990 + { + first_byte = b; + codeset = 4; + } + else // codeset == 4 // third byte of JIS X 0212-1990 + { + first_byte -= 0x80 + 34; + b -= 0x80 + 33; + if ((unsigned) first_byte >= 76 || (unsigned) b >= 94) + b = ERROR_CHAR; + else + { + b = JIS0208_to_Unicode[first_byte][b]; + if (b == 0) + b = ERROR_CHAR; + } + elements(outbuffer)[outpos++] = b; + codeset = 0; + } + } + return outpos - start_outpos; +} diff --git a/libjava/gnu/gcj/protocol/http/Connection.java b/libjava/gnu/gcj/protocol/http/Connection.java new file mode 100644 index 00000000000..aee6fdd3e57 --- /dev/null +++ b/libjava/gnu/gcj/protocol/http/Connection.java @@ -0,0 +1,285 @@ +// Connection.java - Implementation of HttpURLConnection for http protocol. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.protocol.http; + +import java.net.*; +import java.io.*; +import java.util.Vector; +import java.util.Hashtable; +import java.util.Enumeration; + +/** + * @author Warren Levy + * @date March 29, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Minimal subset of functionality. Proxies and Redirects + * not yet handled. FileNameMap handling needs to be considered. + * useCaches, ifModifiedSince, and allowUserInteraction need + * consideration as well as doInput and doOutput. + */ + +class Connection extends HttpURLConnection +{ + protected Socket sock = null; + private static Hashtable defRequestProperties = new Hashtable(); + private Hashtable requestProperties; + private Hashtable hdrHash = new Hashtable(); + private Vector hdrVec = new Vector(); + private boolean gotHeaders = false; + private BufferedInputStream bufferedIn; + + public Connection(URL url) + { + super(url); + requestProperties = (Hashtable) defRequestProperties.clone(); + } + + // Override method in URLConnection. + public static void setDefaultRequestProperty(String key, String value) + { + defRequestProperties.put(key, value); + } + + // Override method in URLConnection. + public static String getDefaultRequestProperty(String key) + { + return (String) defRequestProperties.get(key); + } + + // Override method in URLConnection. + public void setRequestProperty(String key, String value) + { + if (connected) + throw new IllegalAccessError("Connection already established."); + + requestProperties.put(key, value); + } + + // Override method in URLConnection. + public String getRequestProperty(String key) + { + if (connected) + throw new IllegalAccessError("Connection already established."); + + return (String) requestProperties.get(key); + } + + // Implementation of abstract method. + public void connect() throws IOException + { + // Call is ignored if already connected. + if (connected) + return; + + // Get address and port number. + int port; + InetAddress destAddr = InetAddress.getByName(url.getHost()); + if ((port = url.getPort()) == -1) + port = 80; + + // Open socket and output stream. + sock = new Socket(destAddr, port); + PrintWriter out = new PrintWriter(sock.getOutputStream()); + + // Send request including any request properties that were set. + out.print(getRequestMethod() + " " + url.getFile() + " HTTP/1.1\n"); + out.print("Host: " + url.getHost() + ":" + port + "\n"); + Enumeration reqKeys = requestProperties.keys(); + Enumeration reqVals = requestProperties.elements(); + while (reqKeys.hasMoreElements()) + out.print(reqKeys.nextElement() + ": " + reqVals.nextElement() + "\n"); + out.print("\n"); + out.flush(); + connected = true; + } + + // Implementation of abstract method. + public void disconnect() + { + if (sock != null) + { + try + { + sock.close(); + } + catch (IOException ex) + { + ; // Ignore errors in closing socket. + } + sock = null; + } + connected = false; + } + + // TODO: public boolean usingProxy() + public boolean usingProxy() + { + throw new InternalError("HttpURLConnection.usingProxy not implemented"); + } + + // Override default method in URLConnection. + public InputStream getInputStream() throws IOException + { + if (!connected) + connect(); + + if (bufferedIn == null) + bufferedIn = new BufferedInputStream(sock.getInputStream()); + return bufferedIn; + } + + // Override default method in URLConnection. + public OutputStream getOutputStream() throws IOException + { + if (!connected) + connect(); + + return sock.getOutputStream(); + } + + // Override default method in URLConnection. + public String getHeaderField(String name) + { + try + { + getHttpHeaders(); + } + catch (IOException x) + { + return null; + } + return (String) hdrHash.get(name.toLowerCase()); + } + + // Override default method in URLConnection. + public String getHeaderField(int n) + { + try + { + getHttpHeaders(); + } + catch (IOException x) + { + return null; + } + if (n < hdrVec.size()) + return getField((String) hdrVec.elementAt(n)); + + return null; + } + + // Override default method in URLConnection. + public String getHeaderFieldKey(int n) + { + try + { + getHttpHeaders(); + } + catch (IOException x) + { + return null; + } + if (n < hdrVec.size()) + return getKey((String) hdrVec.elementAt(n)); + + return null; + } + + private String getKey(String str) + { + if (str == null) + return null; + int index = str.indexOf(':'); + if (index >= 0) + return str.substring(0, index); + else + return null; + } + + private String getField(String str) + { + if (str == null) + return null; + int index = str.indexOf(':'); + if (index >= 0) + return str.substring(index + 1).trim(); + else + return str; + } + + private void getHttpHeaders() throws IOException + { + if (gotHeaders) + return; + gotHeaders = true; + + connect(); + + // Originally tried using a BufferedReader here to take advantage of + // the readLine method and avoid the following, but the buffer read + // past the end of the headers so the first part of the content was lost. + // It is probably more robust than it needs to be, e.g. the byte[] + // is unlikely to overflow and a '\r' should always be followed by a '\n', + // but it is better to be safe just in case. + if (bufferedIn == null) + bufferedIn = new BufferedInputStream(sock.getInputStream()); + + int buflen = 100; + byte[] buf = new byte[buflen]; + String line = ""; + boolean gotnl = false; + byte[] ch = new byte[1]; + ch[0] = (byte) '\n'; + while (true) + { + // Check for leftover byte from non-'\n' after a '\r'. + if (ch[0] != '\n') + line = line + '\r' + new String(ch, 0, 1); + + int i; + for (i = 0; i < buflen; i++) + { + bufferedIn.read(buf, i, 1); + if (buf[i] == '\r') + { + bufferedIn.read(ch, 0, 1); + if (ch[0] == '\n') + gotnl = true; + break; + } + } + line = line + new String(buf, 0, i); + + // A '\r' '\n' combo indicates the end of the header entry. + // If it wasn't found, cycle back through the loop and append + // to 'line' until one is found. + if (gotnl) + { + // A zero length entry signals the end of the headers. + if (line.length() == 0) + break; + + // Store the header and reinitialize for next cycle. + hdrVec.addElement(line); + String key = getKey(line); + if (key != null) + hdrHash.put(key.toLowerCase(), getField(line)); + line = ""; + ch[0] = (byte) '\n'; + gotnl = false; + } + } + } +} diff --git a/libjava/gnu/gcj/protocol/http/Handler.java b/libjava/gnu/gcj/protocol/http/Handler.java new file mode 100644 index 00000000000..7e379890eb2 --- /dev/null +++ b/libjava/gnu/gcj/protocol/http/Handler.java @@ -0,0 +1,35 @@ +// Handler.java - URLStreamHandler for http protocol. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.protocol.http; + +import java.net.URL; +import java.net.URLConnection; +import java.net.URLStreamHandler; +import java.io.IOException; + +/** + * @author Warren Levy + * @date March 26, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Minimal functionality. + */ + +public class Handler extends URLStreamHandler +{ + protected URLConnection openConnection(URL url) throws IOException + { + return new Connection(url); + } +} diff --git a/libjava/gnu/gcj/text/BaseBreakIterator.java b/libjava/gnu/gcj/text/BaseBreakIterator.java new file mode 100644 index 00000000000..794fb2e0c16 --- /dev/null +++ b/libjava/gnu/gcj/text/BaseBreakIterator.java @@ -0,0 +1,82 @@ +// Base class for default BreakIterators. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.text; + +import java.text.BreakIterator; +import java.text.CharacterIterator; + +/** + * @author Tom Tromey + * @date March 22, 1999 + */ + +public abstract class BaseBreakIterator extends BreakIterator +{ + public int current () + { + return iter.getIndex(); + } + + public int first () + { + iter.first(); + return iter.getBeginIndex(); + } + + public int following (int pos) + { + int save = iter.getIndex(); + iter.setIndex(pos); + int r = next (); + iter.setIndex(save); + return r; + } + + public CharacterIterator getText () + { + return iter; + } + + public int last () + { + iter.last(); + return iter.getEndIndex(); + } + + public int next (int n) + { + int r = iter.getIndex (); + if (n > 0) + { + while (n > 0 && r != DONE) + { + r = next (); + --n; + } + } + else if (n < 0) + { + while (n < 0 && r != DONE) + { + r = previous (); + ++n; + } + } + return r; + } + + public void setText (CharacterIterator newText) + { + iter = newText; + } + + protected CharacterIterator iter; +} diff --git a/libjava/gnu/gcj/text/CharacterBreakIterator.java b/libjava/gnu/gcj/text/CharacterBreakIterator.java new file mode 100644 index 00000000000..e1777fd9945 --- /dev/null +++ b/libjava/gnu/gcj/text/CharacterBreakIterator.java @@ -0,0 +1,188 @@ +// Default character BreakIterator. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.text; + +import java.text.BreakIterator; +import java.text.CharacterIterator; + +/** + * @author Tom Tromey + * @date March 19, 1999 + * Written using The Unicode Standard, Version 2.0. + */ + +public class CharacterBreakIterator extends BaseBreakIterator +{ + // Hangul Jamo constants from Unicode book. + private static final int LBase = 0x1100; + private static final int VBase = 0x1161; + private static final int TBase = 0x11a7; + private static final int LCount = 19; + private static final int VCount = 21; + private static final int TCount = 28; + + // Information about surrogates. + private static final int highSurrogateStart = 0xD800; + private static final int highSurrogateEnd = 0xDBFF; + private static final int lowSurrogateStart = 0xDC00; + private static final int lowSurrogateEnd = 0xDFFF; + + public Object clone () + { + return new CharacterBreakIterator (this); + } + + public CharacterBreakIterator () + { + iter = null; // FIXME? + } + + private CharacterBreakIterator (CharacterBreakIterator other) + { + iter = (CharacterIterator) other.iter.clone(); + } + + // Some methods to tell us different properties of characters. + private final boolean isL (char c) + { + return c >= LBase && c <= LBase + LCount; + } + private final boolean isV (char c) + { + return c >= VBase && c <= VBase + VCount; + } + private final boolean isT (char c) + { + return c >= TBase && c <= TBase + TCount; + } + private final boolean isLVT (char c) + { + return isL (c) || isV (c) || isT (c); + } + private final boolean isHighSurrogate (char c) + { + return c >= highSurrogateStart && c <= highSurrogateEnd; + } + private final boolean isLowSurrogate (char c) + { + return c >= lowSurrogateStart && c <= lowSurrogateEnd; + } + + public int next () + { + int end = iter.getEndIndex(); + if (iter.getIndex() == end) + return DONE; + + char c; + for (char prev = CharacterIterator.DONE; iter.getIndex() < end; prev = c) + { + c = iter.next(); + if (c == CharacterIterator.DONE) + break; + int type = Character.getType(c); + + // Break after paragraph separators. + if (type == Character.PARAGRAPH_SEPARATOR) + break; + + // Now we need some lookahead. + char ahead = iter.next(); + iter.previous(); + if (ahead == CharacterIterator.DONE) + break; + int aheadType = Character.getType(ahead); + + if (aheadType != Character.NON_SPACING_MARK + && ! isLowSurrogate (ahead) + && ! isLVT (ahead)) + break; + if (! isLVT (c) && isLVT (ahead)) + break; + if (isL (c) && ! isLVT (ahead) + && aheadType != Character.NON_SPACING_MARK) + break; + if (isV (c) && ! isV (ahead) && !isT (ahead) + && aheadType != Character.NON_SPACING_MARK) + break; + if (isT (c) && ! isT (ahead) + && aheadType != Character.NON_SPACING_MARK) + break; + + if (! isHighSurrogate (c) && isLowSurrogate (ahead)) + break; + if (isHighSurrogate (c) && ! isLowSurrogate (ahead)) + break; + if (! isHighSurrogate (prev) && isLowSurrogate (c)) + break; + } + + return iter.getIndex(); + } + + public int previous () + { + if (iter.getIndex() == iter.getBeginIndex()) + return DONE; + + int start = iter.getBeginIndex(); + while (iter.getIndex() >= iter.getBeginIndex()) + { + char c = iter.previous(); + if (c == CharacterIterator.DONE) + break; + int type = Character.getType(c); + + if (type != Character.NON_SPACING_MARK + && ! isLowSurrogate (c) + && ! isLVT (c)) + break; + + // Now we need some lookahead. + char ahead = iter.previous(); + if (ahead == CharacterIterator.DONE) + { + iter.next(); + break; + } + char ahead2 = iter.previous(); + iter.next(); + iter.next(); + if (ahead2 == CharacterIterator.DONE) + break; + int aheadType = Character.getType(ahead); + + if (aheadType == Character.PARAGRAPH_SEPARATOR) + break; + + if (isLVT (c) && ! isLVT (ahead)) + break; + if (! isLVT (c) && type != Character.NON_SPACING_MARK + && isL (ahead)) + break; + if (! isV (c) && ! isT (c) && type != Character.NON_SPACING_MARK + && isV (ahead)) + break; + if (! isT (c) && type != Character.NON_SPACING_MARK + && isT (ahead)) + break; + + if (isLowSurrogate (c) && ! isHighSurrogate (ahead)) + break; + if (! isLowSurrogate (c) && isHighSurrogate (ahead)) + break; + if (isLowSurrogate (ahead) && ! isHighSurrogate (ahead2)) + break; + } + + return iter.getIndex(); + } +} diff --git a/libjava/gnu/gcj/text/LineBreakIterator.java b/libjava/gnu/gcj/text/LineBreakIterator.java new file mode 100644 index 00000000000..b42881c864e --- /dev/null +++ b/libjava/gnu/gcj/text/LineBreakIterator.java @@ -0,0 +1,168 @@ +// Default word BreakIterator. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.text; + +import java.text.BreakIterator; +import java.text.CharacterIterator; + +/** + * @author Tom Tromey + * @date March 22, 1999 + * Written using The Unicode Standard, Version 2.0. + */ + +public class LineBreakIterator extends BaseBreakIterator +{ + public Object clone () + { + return new LineBreakIterator (this); + } + + public LineBreakIterator () + { + iter = null; + } + + private LineBreakIterator (LineBreakIterator other) + { + iter = (CharacterIterator) other.iter.clone(); + } + + // Some methods to tell us different properties of characters. + private final boolean isNb (char c) + { + return (c == 0x00a0 // NO-BREAK SPACE + || c == 0x2011 // NON-BREAKING HYPHEN + || c == 0xfeff); // ZERO WITH NO-BREAK SPACE + } + private final boolean isClose (int type) + { + return (type == Character.END_PUNCTUATION + // Unicode book says "comma, period, ...", which I take to + // mean "Po" class. + || type == Character.OTHER_PUNCTUATION); + } + private final boolean isIdeo (char c) + { + return (c >= 0x3040 && c <= 0x309f // Hiragana + || c >= 0x30a0 && c <= 0x30ff // Katakana + || c >= 0x4e00 && c <= 0x9fff // Han + || c >= 0x3100 && c <= 0x312f); // Bopomofo + } + + public int next () + { + int end = iter.getEndIndex(); + if (iter.getIndex() == end) + return DONE; + + while (iter.getIndex() < end) + { + char c = iter.current(); + int type = Character.getType(c); + + char n = iter.next(); + + if (n == CharacterIterator.DONE + || type == Character.PARAGRAPH_SEPARATOR + || type == Character.LINE_SEPARATOR) + break; + + // Handle two cases where we must scan for non-spacing marks. + int start = iter.getIndex(); + if (type == Character.SPACE_SEPARATOR + || type == Character.START_PUNCTUATION + || isIdeo (c)) + { + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.NON_SPACING_MARK) + n = iter.next(); + if (n == CharacterIterator.DONE) + break; + + if (type == Character.SPACE_SEPARATOR) + { + int nt = Character.getType(n); + if (nt != Character.NON_SPACING_MARK + && nt != Character.SPACE_SEPARATOR + && ! isNb (n)) + break; + } + else if (type == Character.START_PUNCTUATION) + { + if (isIdeo (n)) + { + // Open punctuation followed by non spacing marks + // and then ideograph does not have a break in + // it. So skip all this. + start = iter.getIndex(); + } + } + else + { + // Ideograph preceded this character. + if (isClose (Character.getType(n))) + break; + } + } + iter.setIndex(start); + } + + return iter.getIndex(); + } + + public int previous () + { + int start = iter.getBeginIndex(); + if (iter.getIndex() == start) + return DONE; + + while (iter.getIndex() >= start) + { + char c = iter.previous(); + if (c == CharacterIterator.DONE) + break; + int type = Character.getType(c); + + char n = iter.previous(); + if (n == CharacterIterator.DONE) + break; + iter.next(); + + int nt = Character.getType(n); + // Break after paragraph separators. + if (nt == Character.PARAGRAPH_SEPARATOR + || nt == Character.LINE_SEPARATOR) + break; + + // Skip non-spacing marks. + int init = iter.getIndex(); + while (n != CharacterIterator.DONE && nt == Character.NON_SPACING_MARK) + { + n = iter.previous(); + nt = Character.getType(n); + } + + if (nt == Character.SPACE_SEPARATOR + && type != Character.SPACE_SEPARATOR + && type != Character.NON_SPACING_MARK + && ! isNb (c)) + break; + if (! isClose (type) && isIdeo (n)) + break; + if (isIdeo (c) && nt != Character.START_PUNCTUATION) + break; + iter.setIndex(init); + } + + return iter.getIndex(); + } +} diff --git a/libjava/gnu/gcj/text/LocaleData_en.java b/libjava/gnu/gcj/text/LocaleData_en.java new file mode 100644 index 00000000000..df5a0de8a40 --- /dev/null +++ b/libjava/gnu/gcj/text/LocaleData_en.java @@ -0,0 +1,75 @@ +// Generic English locale data for java.text. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.text; + +import java.util.ListResourceBundle; + +/** + * @author Tom Tromey + * @date March 4, 1999 + */ + +public final class LocaleData_en extends ListResourceBundle +{ + // These are for DateFormatSymbols. + static final String[] ampmsDefault = {"AM", "PM" }; + static final String[] erasDefault = {"BC", "AD" }; + static final String localPatternCharsDefault = "GyMdkHmsSEDFwWahKz"; + static final String[] monthsDefault = { + "January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December", "" + }; + static final String[] shortMonthsDefault = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "" + }; + static final String[] shortWeekdaysDefault = { + "", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" + }; + static final String[] weekdaysDefault = { + "", "Sunday", "Monday", "Tuesday", + "Wednesday", "Thursday", "Friday", "Saturday" + }; + + private static final Object[][] contents = + { + // These are for DecimalFormatSymbols. + { "decimalSeparator", "." }, + { "digit", "#" }, + { "exponential", "E" }, + { "groupingSeparator", "," }, + { "infinity", "\u221e" }, + { "minusSign", "-" }, + { "NaN", "\ufffd" }, + { "patternSeparator", ";" }, + { "percent", "%" }, + { "perMill", "\u2030" }, + { "zeroDigit", "0" }, + + // These are for NumberFormat. + { "numberFormat", "#,##0.###" }, + { "percentFormat", "#,##0%" }, + + // These are for DateFormatSymbols. + { "ampm", ampmsDefault }, + { "eras", erasDefault }, + { "datePatternChars", localPatternCharsDefault }, + { "months", monthsDefault }, + { "shortMonths", shortMonthsDefault }, + { "shortWeekdays", shortWeekdaysDefault }, + { "weekdays", weekdaysDefault } + }; + + protected Object[][] getContents () + { + return contents; + } +} diff --git a/libjava/gnu/gcj/text/LocaleData_en_US.java b/libjava/gnu/gcj/text/LocaleData_en_US.java new file mode 100644 index 00000000000..a0f02097975 --- /dev/null +++ b/libjava/gnu/gcj/text/LocaleData_en_US.java @@ -0,0 +1,71 @@ +// US English locale data for java.text. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.text; + +import java.util.ListResourceBundle; + +/** + * @author Tom Tromey + * @date March 4, 1999 + */ + +public final class LocaleData_en_US extends ListResourceBundle +{ + // These are for DateFormatSymbols. + static String[][] zoneStringsDefault = { + { "PST", "Pacific Standard Time", "PST", + /**/ "Pacific Daylight Time", "PDT", "San Francisco" }, + { "MST", "Mountain Standard Time", "MST", + /**/ "Mountain Daylight Time", "MDT", "Denver" }, + { "PNT", "Mountain Standard Time", "MST", + /**/ "Mountain Standard Time", "MST", "Phoenix" }, + { "CST", "Central Standard Time", "CST", + /**/ "Central Daylight Time", "CDT", "Chicago" }, + { "EST", "Eastern Standard Time", "EST", + /**/ "Eastern Daylight Time", "EDT", "Boston" }, + { "IET", "Eastern Standard Time", "EST", + /**/ "Eastern Standard Time", "EST", "Indianapolis" }, + { "PRT", "Atlantic Standard Time", "AST", + /**/ "Atlantic Daylight Time", "ADT", "Halifax" }, + { "HST", "Hawaii Standard Time", "HST", + /**/ "Hawaii Daylight Time", "HDT", "Honolulu" }, + { "AST", "Alaska Standard Time", "AST", + /**/ "Alaska Daylight Time", "ADT", "Anchorage" } + }; + + private static final Object[][] contents = + { + // These are for DecimalFormatSymbols. + { "currency", "$" }, + { "intlCurrencySymbol", "$" }, // FIXME? + + // These are for NumberFormat. + { "currencyFormat", "$#,##0.00;($#,##0.00)" }, + + // These are for DateFormatSymbols. + { "zoneStrings", zoneStringsDefault }, + + // These are for DateFormat. + { "shortDateFormat", "M/d/yy" }, // Java's Y2K bug. + { "mediumDateFormat", "d-MMM-yy" }, + { "longDateFormat", "MMMM d, yyyy" }, + { "fullDateFormat", "EEEE MMMM d, yyyy G" }, + { "shortTimeFormat", "h:mm a" }, + { "mediumTimeFormat", "h:mm:ss a" }, + { "longTimeFormat", "h:mm:ss a z" }, + { "fullTimeFormat", "h:mm:ss;S 'o''clock' a z" } + }; + + protected Object[][] getContents () + { + return contents; + } +} diff --git a/libjava/gnu/gcj/text/SentenceBreakIterator.java b/libjava/gnu/gcj/text/SentenceBreakIterator.java new file mode 100644 index 00000000000..8668087b23f --- /dev/null +++ b/libjava/gnu/gcj/text/SentenceBreakIterator.java @@ -0,0 +1,226 @@ +// Default sentence BreakIterator. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.text; + +import java.text.BreakIterator; +import java.text.CharacterIterator; + +/** + * @author Tom Tromey + * @date March 23, 1999 + * Written using The Unicode Standard, Version 2.0. + */ + +public class SentenceBreakIterator extends BaseBreakIterator +{ + public Object clone () + { + return new SentenceBreakIterator (this); + } + + public SentenceBreakIterator () + { + iter = null; + } + + private SentenceBreakIterator (SentenceBreakIterator other) + { + iter = (CharacterIterator) other.iter.clone(); + } + + public int next () + { + int end = iter.getEndIndex(); + if (iter.getIndex() == end) + return DONE; + + while (iter.getIndex() < end) + { + char c = iter.current(); + if (c == CharacterIterator.DONE) + break; + int type = Character.getType(c); + + char n = iter.next(); + if (n == CharacterIterator.DONE) + break; + + // Always break after paragraph separator. + if (type == Character.PARAGRAPH_SEPARATOR) + break; + + if (c == '!' || c == '?') + { + // Skip close punctuation. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.END_PUNCTUATION) + n = iter.next(); + // Skip spaces. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.SPACE_SEPARATOR) + n = iter.next(); + // Skip optional paragraph separator. + if (n != CharacterIterator.DONE + && Character.getType(n) == Character.PARAGRAPH_SEPARATOR) + n = iter.next(); + + // There's always a break somewhere after `!' or `?'. + break; + } + + if (c == '.') + { + int save = iter.getIndex(); + // Skip close punctuation. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.END_PUNCTUATION) + n = iter.next(); + // Skip spaces. We keep count because we need at least + // one for this period to represent a terminator. + int spcount = 0; + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.SPACE_SEPARATOR) + { + n = iter.next(); + ++spcount; + } + if (spcount > 0) + { + int save2 = iter.getIndex(); + // Skip over open puncutation. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.START_PUNCTUATION) + n = iter.next(); + // Next character must not be lower case. + if (n == CharacterIterator.DONE + || ! Character.isLowerCase(n)) + { + iter.setIndex(save2); + break; + } + } + iter.setIndex(save); + } + } + + return iter.getIndex(); + } + + private final int previous_internal () + { + int start = iter.getBeginIndex(); + if (iter.getIndex() == start) + return DONE; + + while (iter.getIndex() >= start) + { + char c = iter.previous(); + if (c == CharacterIterator.DONE) + break; + + char n = iter.previous(); + if (n == CharacterIterator.DONE) + break; + iter.next(); + int nt = Character.getType(n); + + if (! Character.isLowerCase(c) + && (nt == Character.START_PUNCTUATION + || nt == Character.SPACE_SEPARATOR)) + { + int save = iter.getIndex(); + int save_nt = nt; + char save_n = n; + // Skip open punctuation. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.START_PUNCTUATION) + n = iter.previous(); + if (n == CharacterIterator.DONE) + break; + if (Character.getType(n) == Character.SPACE_SEPARATOR) + { + // Must have at least once space after the `.'. + int save2 = iter.getIndex(); + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.SPACE_SEPARATOR) + n = iter.previous(); + // Skip close punctuation. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.END_PUNCTUATION) + n = iter.previous(); + if (n == CharacterIterator.DONE || n == '.') + { + // Communicate location of actual end. + period = iter.getIndex(); + iter.setIndex(save2); + break; + } + } + iter.setIndex(save); + nt = save_nt; + n = save_n; + } + + if (nt == Character.PARAGRAPH_SEPARATOR) + { + // Communicate location of actual end. + period = iter.getIndex(); + break; + } + else if (nt == Character.SPACE_SEPARATOR + || nt == Character.END_PUNCTUATION) + { + int save = iter.getIndex(); + // Skip spaces. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.SPACE_SEPARATOR) + n = iter.previous(); + // Skip close punctuation. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.END_PUNCTUATION) + n = iter.previous(); + int here = iter.getIndex(); + iter.setIndex(save); + if (n == CharacterIterator.DONE || n == '!' || n == '?') + { + // Communicate location of actual end. + period = here; + break; + } + } + else if (n == '!' || n == '?') + { + // Communicate location of actual end. + period = iter.getIndex(); + break; + } + } + + return iter.getIndex(); + } + + public int previous () + { + // We want to skip over the first sentence end to the second one. + // However, at the end of the string we want the first end. + int here = iter.getIndex(); + period = here; + int first = previous_internal (); + if (here == iter.getEndIndex() || first == DONE) + return first; + iter.setIndex(period); + return previous_internal (); + } + + // This is used for communication between previous and + // previous_internal. + private int period; +} diff --git a/libjava/gnu/gcj/text/WordBreakIterator.java b/libjava/gnu/gcj/text/WordBreakIterator.java new file mode 100644 index 00000000000..b2fcb97a1a1 --- /dev/null +++ b/libjava/gnu/gcj/text/WordBreakIterator.java @@ -0,0 +1,224 @@ +// Default word BreakIterator. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.gcj.text; + +import java.text.BreakIterator; +import java.text.CharacterIterator; + +/** + * @author Tom Tromey + * @date March 22, 1999 + * Written using The Unicode Standard, Version 2.0. + */ + +public class WordBreakIterator extends BaseBreakIterator +{ + public Object clone () + { + return new WordBreakIterator (this); + } + + public WordBreakIterator () + { + iter = null; + } + + private WordBreakIterator (WordBreakIterator other) + { + iter = (CharacterIterator) other.iter.clone(); + } + + // Some methods to tell us different properties of characters. + private final boolean isHira (char c) + { + return c >= 0x3040 && c <= 0x309f; + } + private final boolean isKata (char c) + { + return c >= 0x30a0 && c <= 0x30ff; + } + private final boolean isHan (char c) + { + return c >= 0x4e00 && c <= 0x9fff; + } + + public int next () + { + int end = iter.getEndIndex(); + if (iter.getIndex() == end) + return DONE; + + while (iter.getIndex() < end) + { + char c = iter.current(); + if (c == CharacterIterator.DONE) + break; + int type = Character.getType(c); + + char n = iter.next(); + if (n == CharacterIterator.DONE) + break; + + // Break after paragraph separators. + if (type == Character.PARAGRAPH_SEPARATOR + || type == Character.LINE_SEPARATOR) + break; + + // Break between letters and non-letters. + // FIXME: we treat apostrophe as part of a word. This + // is an English-ism. + boolean is_letter = Character.isLetter(c); + if (c != '\'' && ! is_letter && type != Character.NON_SPACING_MARK + && Character.isLetter(n)) + break; + + // Always break after certain symbols, such as punctuation. + // This heuristic is derived from hints in the JCL book and is + // not part of Unicode. It seems to be right, however. + // FIXME: we treat apostrophe as part of a word. This + // is an English-ism. + if (c != '\'' + && (type == Character.DASH_PUNCTUATION + || type == Character.START_PUNCTUATION + || type == Character.END_PUNCTUATION + || type == Character.CONNECTOR_PUNCTUATION + || type == Character.OTHER_PUNCTUATION + || type == Character.MATH_SYMBOL + || type == Character.CURRENCY_SYMBOL + || type == Character.MODIFIER_SYMBOL + || type == Character.OTHER_SYMBOL + || type == Character.FORMAT + || type == Character.CONTROL)) + break; + + boolean is_hira = isHira (c); + boolean is_kata = isKata (c); + boolean is_han = isHan (c); + + // Special case Japanese. + if (! is_hira && ! is_kata && ! is_han + && type != Character.NON_SPACING_MARK + && (isHira (n) || isKata (n) || isHan (n))) + break; + + if (is_hira || is_kata || is_han || is_letter) + { + // Now we need to do some lookahead. We might need to do + // quite a bit of lookahead, so we save our position and + // restore it later. + int save = iter.getIndex(); + // Skip string of non spacing marks. + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.NON_SPACING_MARK) + n = iter.next(); + if (n == CharacterIterator.DONE) + break; + if ((is_hira && ! isHira (n)) + || (is_kata && ! isHira (n) && ! isKata (n)) + || (is_han && ! isHira (n) && ! isHan (n)) + // FIXME: we treat apostrophe as part of a word. This + // is an English-ism. + || (is_letter && ! Character.isLetter(n) && n != '\'')) + break; + iter.setIndex(save); + } + } + + return iter.getIndex(); + } + + public int previous () + { + int start = iter.getBeginIndex(); + if (iter.getIndex() == start) + return DONE; + + while (iter.getIndex() >= start) + { + char c = iter.previous(); + if (c == CharacterIterator.DONE) + break; + + boolean is_hira = isHira (c); + boolean is_kata = isKata (c); + boolean is_han = isHan (c); + boolean is_letter = Character.isLetter(c); + + char n = iter.previous(); + if (n == CharacterIterator.DONE) + break; + iter.next(); + int type = Character.getType(n); + // Break after paragraph separators. + if (type == Character.PARAGRAPH_SEPARATOR + || type == Character.LINE_SEPARATOR) + break; + + // Break between letters and non-letters. + // FIXME: we treat apostrophe as part of a word. This + // is an English-ism. + if (n != '\'' && ! Character.isLetter(n) + && type != Character.NON_SPACING_MARK + && is_letter) + break; + + // Always break after certain symbols, such as punctuation. + // This heuristic is derived from hints in the JCL book and is + // not part of Unicode. It seems to be right, however. + // FIXME: we treat apostrophe as part of a word. This + // is an English-ism. + if (n != '\'' + && (type == Character.DASH_PUNCTUATION + || type == Character.START_PUNCTUATION + || type == Character.END_PUNCTUATION + || type == Character.CONNECTOR_PUNCTUATION + || type == Character.OTHER_PUNCTUATION + || type == Character.MATH_SYMBOL + || type == Character.CURRENCY_SYMBOL + || type == Character.MODIFIER_SYMBOL + || type == Character.OTHER_SYMBOL + || type == Character.FORMAT + || type == Character.CONTROL)) + break; + + // Special case Japanese. + if ((is_hira || is_kata || is_han) + && ! isHira (n) && ! isKata (n) && ! isHan (n) + && type != Character.NON_SPACING_MARK) + break; + + // We might have to skip over non spacing marks to see what's + // on the other side. + if (! is_hira || (! is_letter && c != '\'')) + { + int save = iter.getIndex(); + while (n != CharacterIterator.DONE + && Character.getType(n) == Character.NON_SPACING_MARK) + n = iter.previous(); + iter.setIndex(save); + // This is a strange case: a bunch of non-spacing marks at + // the beginning. We treat the current location as a word + // break. + if (n == CharacterIterator.DONE) + break; + if ((isHira (n) && ! is_hira) + || (isKata (n) && ! is_hira && ! is_kata) + || (isHan (n) && ! is_hira && ! is_han) + // FIXME: we treat apostrophe as part of a word. This + // is an English-ism. + || (! is_letter && c != '\'' && Character.isLetter(n))) + break; + } + } + + return iter.getIndex(); + } +} diff --git a/libjava/include/boehm-gc.h b/libjava/include/boehm-gc.h new file mode 100644 index 00000000000..6081a8981bf --- /dev/null +++ b/libjava/include/boehm-gc.h @@ -0,0 +1,24 @@ +// -*- c++ -*- +// boehm-gc.h - Defines for Boehm collector. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JV_BOEHM_GC__ +#define __JV_BOEHM_GC__ + +#define JV_MARKOBJ_DECL void *_Jv_MarkObj (void *, void *, void *, void *) +#define JV_MARKARRAY_DECL void *_Jv_MarkArray (void *, void *, void *, void *) + +extern "C" +{ + JV_MARKOBJ_DECL; + JV_MARKARRAY_DECL; +}; + +#endif /* __JV_BOEHM_GC__ */ diff --git a/libjava/include/cni.h b/libjava/include/cni.h new file mode 100644 index 00000000000..b9b202d41dd --- /dev/null +++ b/libjava/include/cni.h @@ -0,0 +1,133 @@ +// cni.h -*- c++ -*- +// This file describes the Cygnus Native Interface, CNI. +// It provides a nicer interface to many of the things in javaprims.h. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVA_CNI_H__ +#define __JAVA_CNI_H__ + +#include +#include + +#include +#include + +extern inline jobject +JvAllocObject (jclass cls) +{ + return _Jv_AllocObject (cls, cls->size()); +} + +extern inline jobject +JvAllocObject (jclass cls, jsize sz) +{ + return _Jv_AllocObject (cls, sz); +} + +extern "C" jstring _Jv_NewStringUTF (const char *bytes); +extern "C" void _Jv_InitClass (jclass); + +extern inline void +JvInitClass (jclass cls) +{ + return _Jv_InitClass (cls); +} + +extern inline jstring +JvAllocString (jsize sz) +{ + return _Jv_AllocString (sz); +} + +extern inline jstring +JvNewString (const jchar *chars, jsize len) +{ + return _Jv_NewString (chars, len); +} + +extern inline jstring +JvNewStringLatin1 (const char *bytes, jsize len) +{ + return _Jv_NewStringLatin1 (bytes, len); +} + +extern inline jstring +JvNewStringLatin1 (const char *bytes) +{ + return _Jv_NewStringLatin1 (bytes, strlen (bytes)); +} + +extern inline jchar * +_Jv_GetStringChars (jstring str) +{ + return (jchar*)((char*) str->data + str->boffset); +} + +extern inline jchar* +JvGetStringChars (jstring str) +{ + return _Jv_GetStringChars (str); +} + +extern inline jsize +JvGetStringUTFLength (jstring string) +{ + return _Jv_GetStringUTFLength (string); +} + +extern inline jsize +JvGetStringUTFRegion (jstring str, jsize start, jsize len, char *buf) +{ + return _Jv_GetStringUTFRegion (str, start, len, buf); +} + +extern inline jstring +JvNewStringUTF (const char *bytes) +{ + return _Jv_NewStringUTF (bytes); +} + +extern class _Jv_PrimClass _Jv_byteClass, _Jv_shortClass, _Jv_intClass, + _Jv_longClass, _Jv_booleanClass, _Jv_charClass, _Jv_floatClass, + _Jv_doubleClass, _Jv_voidClass; +#define JvPrimClass(TYPE) ((jclass) & _Jv_##TYPE##Class) + +class JvSynchronize +{ +private: + jobject obj; +public: + JvSynchronize (const jobject &o) : obj (o) + { _Jv_MonitorEnter (obj); } + ~JvSynchronize () + { _Jv_MonitorExit (obj); } +}; + +// Throw some exception. +extern void JvThrow (jobject obj) __attribute__ ((__noreturn__)); +extern inline void +JvThrow (jobject obj) +{ + _Jv_Throw ((void *) obj); +} + +/* Call malloc, but throw exception if insufficient memory. */ +extern inline void * +JvMalloc (jsize size) +{ + return _Jv_Malloc (size); +} + +extern inline void +JvFree (void *ptr) +{ + return _Jv_Free (ptr); +} +#endif /* __JAVA_CNI_H__ */ diff --git a/libjava/include/config.h.in b/libjava/include/config.h.in new file mode 100644 index 00000000000..7575b771a3d --- /dev/null +++ b/libjava/include/config.h.in @@ -0,0 +1,252 @@ +/* include/config.h.in. Generated automatically from configure.in by autoheader. */ + +/* Define if using alloca.c. */ +#undef C_ALLOCA + +/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems. + This function is required for alloca.c support on those systems. */ +#undef CRAY_STACKSEG_END + +/* Define if you have alloca, as a function or macro. */ +#undef HAVE_ALLOCA + +/* Define if you have and it should be used (not on Ultrix). */ +#undef HAVE_ALLOCA_H + +/* If using the C implementation of alloca, define if you know the + direction of stack growth for your system; otherwise it will be + automatically deduced at run-time. + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown + */ +#undef STACK_DIRECTION + +/* Define this if you want runtime debugging enabled. */ +#undef DEBUG + +/* Define if using POSIX threads that have the mutexattr functions. */ +#undef HAVE_PTHREAD_MUTEXATTR_INIT + +/* Define this if you prefer size over speed for java.lang.Character. */ +#undef COMPACT_CHARACTER + +/* Define if you have memcpy. */ +#undef HAVE_MEMCPY + +/* Define if you have memmove. */ +#undef HAVE_MEMMOVE + +/* Define if you have strerror. */ +#undef HAVE_STRERROR + +/* Define if you have __int32_t and __uint32_t. */ +#undef HAVE_INT32_DEFINED + +/* Define if you're running eCos. */ +#undef ECOS + +/* */ +#undef HAVE_LOCALTIME + +/* */ +#undef HAVE_MKTIME + +/* Define if using POSIX threads on Linux. */ +#undef LINUX_THREADS + +/* Define if you have the `ctime_r' function. */ +#undef HAVE_CTIME_R + +/* Define if you have the `gmtime_r' function. */ +#undef HAVE_GMTIME_R + +/* Define if you have the `localtime_r' function. */ +#undef HAVE_LOCALTIME_R + +/* Define if inet6 structures are defined in netinet/in.h. */ +#undef HAVE_INET6 + +/* Define it socklen_t typedef is in sys/socket.h. */ +#undef HAVE_SOCKLEN_T + +/* Define if Boehm GC in use. */ +#undef HAVE_BOEHM_GC + +/* Define if gethostname is declared in . */ +#undef HAVE_GETHOSTNAME_DECL + +/* Define if gethostbyname_r returns `int'. */ +#undef GETHOSTBYNAME_R_RETURNS_INT + +/* Define if gethostbyaddr_r returns `int'. */ +#undef GETHOSTBYADDR_R_RETURNS_INT + +/* Define if struct tm has tm_gmtoff field. */ +#undef STRUCT_TM_HAS_GMTOFF + +/* Define if global `timezone' exists. */ +#undef HAVE_TIMEZONE + +/* Define if you have the appropriate function. */ +#undef HAVE_ACCESS +#undef HAVE_STAT +#undef HAVE_MKDIR +#undef HAVE_RENAME +#undef HAVE_RMDIR +#undef HAVE_UNLINK +#undef HAVE_REALPATH +#undef HAVE_READDIR_R +#undef HAVE_GETHOSTBYNAME_R +#undef HAVE_GETHOSTBYADDR_R + +/* Define if you have the access function. */ +#undef HAVE_ACCESS + +/* Define if you have the ctime function. */ +#undef HAVE_CTIME + +/* Define if you have the ctime_r function. */ +#undef HAVE_CTIME_R + +/* Define if you have the fsync function. */ +#undef HAVE_FSYNC + +/* Define if you have the ftime function. */ +#undef HAVE_FTIME + +/* Define if you have the gethostbyaddr_r function. */ +#undef HAVE_GETHOSTBYADDR_R + +/* Define if you have the gethostbyname_r function. */ +#undef HAVE_GETHOSTBYNAME_R + +/* Define if you have the gethostname function. */ +#undef HAVE_GETHOSTNAME + +/* Define if you have the getpwuid_r function. */ +#undef HAVE_GETPWUID_R + +/* Define if you have the gettimeofday function. */ +#undef HAVE_GETTIMEOFDAY + +/* Define if you have the gmtime_r function. */ +#undef HAVE_GMTIME_R + +/* Define if you have the inet_addr function. */ +#undef HAVE_INET_ADDR + +/* Define if you have the inet_aton function. */ +#undef HAVE_INET_ATON + +/* Define if you have the inet_pton function. */ +#undef HAVE_INET_PTON + +/* Define if you have the ioctl function. */ +#undef HAVE_IOCTL + +/* Define if you have the localtime_r function. */ +#undef HAVE_LOCALTIME_R + +/* Define if you have the memcpy function. */ +#undef HAVE_MEMCPY + +/* Define if you have the memmove function. */ +#undef HAVE_MEMMOVE + +/* Define if you have the mkdir function. */ +#undef HAVE_MKDIR + +/* Define if you have the open function. */ +#undef HAVE_OPEN + +/* Define if you have the pthread_mutexattr_setkind_np function. */ +#undef HAVE_PTHREAD_MUTEXATTR_SETKIND_NP + +/* Define if you have the pthread_mutexattr_settype function. */ +#undef HAVE_PTHREAD_MUTEXATTR_SETTYPE + +/* Define if you have the readdir_r function. */ +#undef HAVE_READDIR_R + +/* Define if you have the realpath function. */ +#undef HAVE_REALPATH + +/* Define if you have the rename function. */ +#undef HAVE_RENAME + +/* Define if you have the rmdir function. */ +#undef HAVE_RMDIR + +/* Define if you have the sched_yield function. */ +#undef HAVE_SCHED_YIELD + +/* Define if you have the select function. */ +#undef HAVE_SELECT + +/* Define if you have the sleep function. */ +#undef HAVE_SLEEP + +/* Define if you have the stat function. */ +#undef HAVE_STAT + +/* Define if you have the strerror function. */ +#undef HAVE_STRERROR + +/* Define if you have the time function. */ +#undef HAVE_TIME + +/* Define if you have the uname function. */ +#undef HAVE_UNAME + +/* Define if you have the unlink function. */ +#undef HAVE_UNLINK + +/* Define if you have the header file. */ +#undef HAVE_ARPA_INET_H + +/* Define if you have the header file. */ +#undef HAVE_DIRENT_H + +/* Define if you have the header file. */ +#undef HAVE_FCNTL_H + +/* Define if you have the header file. */ +#undef HAVE_NETDB_H + +/* Define if you have the header file. */ +#undef HAVE_NETINET_IN_H + +/* Define if you have the header file. */ +#undef HAVE_PWD_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_FILIO_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_IOCTL_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_SELECT_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_SOCKET_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_STAT_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_TIME_H + +/* Define if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define if you have the header file. */ +#undef HAVE_UNISTD_H + +/* Name of package */ +#undef PACKAGE + +/* Version number of package */ +#undef VERSION + diff --git a/libjava/include/java-array.h b/libjava/include/java-array.h new file mode 100644 index 00000000000..3be61b635a2 --- /dev/null +++ b/libjava/include/java-array.h @@ -0,0 +1,78 @@ +// java-array.h - Header file for CNI arrays. -*- c++ -*- + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVA_ARRAY_H__ +#define __JAVA_ARRAY_H__ + +#pragma interface + +#include + +extern "Java" { + +class __JArray : public java::lang::Object +{ +public: + int length; + friend jsize JvGetArrayLength (__JArray*); +}; + +template +class JArray : public __JArray +{ + T data[0]; +public: + friend T* elements<>(JArray& x); + friend T* elements<>(JArray* x); + // T* getData() { return data; } + // T& operator[](jint i) { return data[i]; } +}; + +template +T* elements(JArray& x) { return x.data; } +template +T* elements(JArray* x) { return x->data; } + +}; // end extern "Java" + +/* These typesdefs match those in JNI. */ +typedef __JArray *jarray; +typedef JArray *jobjectArray; +typedef JArray *jbooleanArray; +typedef JArray *jbyteArray; +typedef JArray *jcharArray; +typedef JArray *jshortArray; +typedef JArray *jintArray; +typedef JArray *jlongArray; +typedef JArray *jfloatArray; +typedef JArray *jdoubleArray; +typedef JArray *jstringArray; +// Temporary work-around for gcjh bug. FIXME +typedef JArray *jobjectArrayjchar; + +extern "C" jbooleanArray JvNewBooleanArray (jint length); +extern "C" jbyteArray JvNewByteArray (jint length); +extern "C" jcharArray JvNewCharArray (jint length); +extern "C" jshortArray JvNewShortArray (jint length); +extern "C" jintArray JvNewIntArray (jint length); +extern "C" jlongArray JvNewLongArray (jint length); +extern "C" jfloatArray JvNewFloatArray (jint length); +extern "C" jdoubleArray JvNewDoubleArray (jint length); +extern "C" jobjectArray _Jv_NewObjectArray(jsize length, jclass, jobject init); + +inline jobjectArray JvNewObjectArray (jsize length, jclass cls, jobject init) +{ return _Jv_NewObjectArray (length, cls, init); } + +extern "C" jstringArray JvConvertArgv(int argc, const char **argv); +extern "C" void JvRunMain (jclass klass, int argc, const char **argv); + +inline jsize JvGetArrayLength (jarray array) { return array->length; } + +#endif /* __JAVA_ARRAY_H__ */ diff --git a/libjava/include/java-assert.h b/libjava/include/java-assert.h new file mode 100644 index 00000000000..6e942f2a705 --- /dev/null +++ b/libjava/include/java-assert.h @@ -0,0 +1,38 @@ +// java-assert.h - Header file holding assertion definitions. -*- c++ -*- + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVA_ASSERT_H__ +#define __JAVA_ASSERT_H__ + +// This is a libgcj implementation header. + +void _Jv_Abort (const char *, const char *, int, const char *) + __attribute__ ((__noreturn__)); + +#ifdef DEBUG +#define _Jv_AssertDoCall(Message) _Jv_Abort (__FUNCTION__, __FILE__, __LINE__, Message) + +#define JvAssertMessage(Expr, Message) \ + do { if (! (Expr)) _Jv_AssertDoCall (Message); } while (0) +#define JvAssert(Expr) \ + do { if (! (Expr)) _Jv_AssertDoCall (# Expr); } while (0) + +#define JvFail(Message) _Jv_AssertDoCall (Message) + +#else /* DEBUG */ + +#define _Jv_AssertDoCall(Message) +#define JvAssertMessage(Expr, Message) +#define JvAssert(Expr) +#define JvFail(Message) _Jv_Abort (0, 0, 0, Message) + +#endif /* not DEBUG */ + +#endif /* __JAVA_ASSERT_H__ */ diff --git a/libjava/include/java-chardecomp.h b/libjava/include/java-chardecomp.h new file mode 100644 index 00000000000..346492afbd4 --- /dev/null +++ b/libjava/include/java-chardecomp.h @@ -0,0 +1,3416 @@ +// java-chardecomp.h - Decomposition character tables -*- c++ -*- + +#ifndef __JAVA_CHARDECOMP_H__ +#define __JAVA_CHARDECOMP_H__ + +// These tables are automatically generated by the chartables.pl +// script. DO NOT EDIT the tables. Instead, fix the script +// and run it again. + +// This file should only be included by natCollator.cc + +struct decomp_entry +{ + jchar key; + const char *value; +}; + +static const decomp_entry canonical_decomposition[] = +{ + { 0x00c0, "\x00\x41\x03\x00" }, + { 0x00c1, "\x00\x41\x03\x01" }, + { 0x00c2, "\x00\x41\x03\x02" }, + { 0x00c3, "\x00\x41\x03\x03" }, + { 0x00c4, "\x00\x41\x03\x08" }, + { 0x00c5, "\x00\x41\x03\x0a" }, + { 0x00c7, "\x00\x43\x03\x27" }, + { 0x00c8, "\x00\x45\x03\x00" }, + { 0x00c9, "\x00\x45\x03\x01" }, + { 0x00ca, "\x00\x45\x03\x02" }, + { 0x00cb, "\x00\x45\x03\x08" }, + { 0x00cc, "\x00\x49\x03\x00" }, + { 0x00cd, "\x00\x49\x03\x01" }, + { 0x00ce, "\x00\x49\x03\x02" }, + { 0x00cf, "\x00\x49\x03\x08" }, + { 0x00d1, "\x00\x4e\x03\x03" }, + { 0x00d2, "\x00\x4f\x03\x00" }, + { 0x00d3, "\x00\x4f\x03\x01" }, + { 0x00d4, "\x00\x4f\x03\x02" }, + { 0x00d5, "\x00\x4f\x03\x03" }, + { 0x00d6, "\x00\x4f\x03\x08" }, + { 0x00d9, "\x00\x55\x03\x00" }, + { 0x00da, "\x00\x55\x03\x01" }, + { 0x00db, "\x00\x55\x03\x02" }, + { 0x00dc, "\x00\x55\x03\x08" }, + { 0x00dd, "\x00\x59\x03\x01" }, + { 0x00e0, "\x00\x61\x03\x00" }, + { 0x00e1, "\x00\x61\x03\x01" }, + { 0x00e2, "\x00\x61\x03\x02" }, + { 0x00e3, "\x00\x61\x03\x03" }, + { 0x00e4, "\x00\x61\x03\x08" }, + { 0x00e5, "\x00\x61\x03\x0a" }, + { 0x00e7, "\x00\x63\x03\x27" }, + { 0x00e8, "\x00\x65\x03\x00" }, + { 0x00e9, "\x00\x65\x03\x01" }, + { 0x00ea, "\x00\x65\x03\x02" }, + { 0x00eb, "\x00\x65\x03\x08" }, + { 0x00ec, "\x00\x69\x03\x00" }, + { 0x00ed, "\x00\x69\x03\x01" }, + { 0x00ee, "\x00\x69\x03\x02" }, + { 0x00ef, "\x00\x69\x03\x08" }, + { 0x00f1, "\x00\x6e\x03\x03" }, + { 0x00f2, "\x00\x6f\x03\x00" }, + { 0x00f3, "\x00\x6f\x03\x01" }, + { 0x00f4, "\x00\x6f\x03\x02" }, + { 0x00f5, "\x00\x6f\x03\x03" }, + { 0x00f6, "\x00\x6f\x03\x08" }, + { 0x00f9, "\x00\x75\x03\x00" }, + { 0x00fa, "\x00\x75\x03\x01" }, + { 0x00fb, "\x00\x75\x03\x02" }, + { 0x00fc, "\x00\x75\x03\x08" }, + { 0x00fd, "\x00\x79\x03\x01" }, + { 0x00ff, "\x00\x79\x03\x08" }, + { 0x0100, "\x00\x41\x03\x04" }, + { 0x0101, "\x00\x61\x03\x04" }, + { 0x0102, "\x00\x41\x03\x06" }, + { 0x0103, "\x00\x61\x03\x06" }, + { 0x0104, "\x00\x41\x03\x28" }, + { 0x0105, "\x00\x61\x03\x28" }, + { 0x0106, "\x00\x43\x03\x01" }, + { 0x0107, "\x00\x63\x03\x01" }, + { 0x0108, "\x00\x43\x03\x02" }, + { 0x0109, "\x00\x63\x03\x02" }, + { 0x010a, "\x00\x43\x03\x07" }, + { 0x010b, "\x00\x63\x03\x07" }, + { 0x010c, "\x00\x43\x03\x0c" }, + { 0x010d, "\x00\x63\x03\x0c" }, + { 0x010e, "\x00\x44\x03\x0c" }, + { 0x010f, "\x00\x64\x03\x0c" }, + { 0x0112, "\x00\x45\x03\x04" }, + { 0x0113, "\x00\x65\x03\x04" }, + { 0x0114, "\x00\x45\x03\x06" }, + { 0x0115, "\x00\x65\x03\x06" }, + { 0x0116, "\x00\x45\x03\x07" }, + { 0x0117, "\x00\x65\x03\x07" }, + { 0x0118, "\x00\x45\x03\x28" }, + { 0x0119, "\x00\x65\x03\x28" }, + { 0x011a, "\x00\x45\x03\x0c" }, + { 0x011b, "\x00\x65\x03\x0c" }, + { 0x011c, "\x00\x47\x03\x02" }, + { 0x011d, "\x00\x67\x03\x02" }, + { 0x011e, "\x00\x47\x03\x06" }, + { 0x011f, "\x00\x67\x03\x06" }, + { 0x0120, "\x00\x47\x03\x07" }, + { 0x0121, "\x00\x67\x03\x07" }, + { 0x0122, "\x00\x47\x03\x27" }, + { 0x0123, "\x00\x67\x03\x27" }, + { 0x0124, "\x00\x48\x03\x02" }, + { 0x0125, "\x00\x68\x03\x02" }, + { 0x0128, "\x00\x49\x03\x03" }, + { 0x0129, "\x00\x69\x03\x03" }, + { 0x012a, "\x00\x49\x03\x04" }, + { 0x012b, "\x00\x69\x03\x04" }, + { 0x012c, "\x00\x49\x03\x06" }, + { 0x012d, "\x00\x69\x03\x06" }, + { 0x012e, "\x00\x49\x03\x28" }, + { 0x012f, "\x00\x69\x03\x28" }, + { 0x0130, "\x00\x49\x03\x07" }, + { 0x0134, "\x00\x4a\x03\x02" }, + { 0x0135, "\x00\x6a\x03\x02" }, + { 0x0136, "\x00\x4b\x03\x27" }, + { 0x0137, "\x00\x6b\x03\x27" }, + { 0x0139, "\x00\x4c\x03\x01" }, + { 0x013a, "\x00\x6c\x03\x01" }, + { 0x013b, "\x00\x4c\x03\x27" }, + { 0x013c, "\x00\x6c\x03\x27" }, + { 0x013d, "\x00\x4c\x03\x0c" }, + { 0x013e, "\x00\x6c\x03\x0c" }, + { 0x0143, "\x00\x4e\x03\x01" }, + { 0x0144, "\x00\x6e\x03\x01" }, + { 0x0145, "\x00\x4e\x03\x27" }, + { 0x0146, "\x00\x6e\x03\x27" }, + { 0x0147, "\x00\x4e\x03\x0c" }, + { 0x0148, "\x00\x6e\x03\x0c" }, + { 0x014c, "\x00\x4f\x03\x04" }, + { 0x014d, "\x00\x6f\x03\x04" }, + { 0x014e, "\x00\x4f\x03\x06" }, + { 0x014f, "\x00\x6f\x03\x06" }, + { 0x0150, "\x00\x4f\x03\x0b" }, + { 0x0151, "\x00\x6f\x03\x0b" }, + { 0x0154, "\x00\x52\x03\x01" }, + { 0x0155, "\x00\x72\x03\x01" }, + { 0x0156, "\x00\x52\x03\x27" }, + { 0x0157, "\x00\x72\x03\x27" }, + { 0x0158, "\x00\x52\x03\x0c" }, + { 0x0159, "\x00\x72\x03\x0c" }, + { 0x015a, "\x00\x53\x03\x01" }, + { 0x015b, "\x00\x73\x03\x01" }, + { 0x015c, "\x00\x53\x03\x02" }, + { 0x015d, "\x00\x73\x03\x02" }, + { 0x015e, "\x00\x53\x03\x27" }, + { 0x015f, "\x00\x73\x03\x27" }, + { 0x0160, "\x00\x53\x03\x0c" }, + { 0x0161, "\x00\x73\x03\x0c" }, + { 0x0162, "\x00\x54\x03\x27" }, + { 0x0163, "\x00\x74\x03\x27" }, + { 0x0164, "\x00\x54\x03\x0c" }, + { 0x0165, "\x00\x74\x03\x0c" }, + { 0x0168, "\x00\x55\x03\x03" }, + { 0x0169, "\x00\x75\x03\x03" }, + { 0x016a, "\x00\x55\x03\x04" }, + { 0x016b, "\x00\x75\x03\x04" }, + { 0x016c, "\x00\x55\x03\x06" }, + { 0x016d, "\x00\x75\x03\x06" }, + { 0x016e, "\x00\x55\x03\x0a" }, + { 0x016f, "\x00\x75\x03\x0a" }, + { 0x0170, "\x00\x55\x03\x0b" }, + { 0x0171, "\x00\x75\x03\x0b" }, + { 0x0172, "\x00\x55\x03\x28" }, + { 0x0173, "\x00\x75\x03\x28" }, + { 0x0174, "\x00\x57\x03\x02" }, + { 0x0175, "\x00\x77\x03\x02" }, + { 0x0176, "\x00\x59\x03\x02" }, + { 0x0177, "\x00\x79\x03\x02" }, + { 0x0178, "\x00\x59\x03\x08" }, + { 0x0179, "\x00\x5a\x03\x01" }, + { 0x017a, "\x00\x7a\x03\x01" }, + { 0x017b, "\x00\x5a\x03\x07" }, + { 0x017c, "\x00\x7a\x03\x07" }, + { 0x017d, "\x00\x5a\x03\x0c" }, + { 0x017e, "\x00\x7a\x03\x0c" }, + { 0x01a0, "\x00\x4f\x03\x1b" }, + { 0x01a1, "\x00\x6f\x03\x1b" }, + { 0x01af, "\x00\x55\x03\x1b" }, + { 0x01b0, "\x00\x75\x03\x1b" }, + { 0x01cd, "\x00\x41\x03\x0c" }, + { 0x01ce, "\x00\x61\x03\x0c" }, + { 0x01cf, "\x00\x49\x03\x0c" }, + { 0x01d0, "\x00\x69\x03\x0c" }, + { 0x01d1, "\x00\x4f\x03\x0c" }, + { 0x01d2, "\x00\x6f\x03\x0c" }, + { 0x01d3, "\x00\x55\x03\x0c" }, + { 0x01d4, "\x00\x75\x03\x0c" }, + { 0x01d5, "\x00\xdc\x03\x04" }, + { 0x01d6, "\x00\xfc\x03\x04" }, + { 0x01d7, "\x00\xdc\x03\x01" }, + { 0x01d8, "\x00\xfc\x03\x01" }, + { 0x01d9, "\x00\xdc\x03\x0c" }, + { 0x01da, "\x00\xfc\x03\x0c" }, + { 0x01db, "\x00\xdc\x03\x00" }, + { 0x01dc, "\x00\xfc\x03\x00" }, + { 0x01de, "\x00\xc4\x03\x04" }, + { 0x01df, "\x00\xe4\x03\x04" }, + { 0x01e0, "\x00\x41\x03\x07\x03\x04" }, + { 0x01e1, "\x00\x61\x03\x07\x03\x04" }, + { 0x01e2, "\x00\xc6\x03\x04" }, + { 0x01e3, "\x00\xe6\x03\x04" }, + { 0x01e6, "\x00\x47\x03\x0c" }, + { 0x01e7, "\x00\x67\x03\x0c" }, + { 0x01e8, "\x00\x4b\x03\x0c" }, + { 0x01e9, "\x00\x6b\x03\x0c" }, + { 0x01ea, "\x00\x4f\x03\x28" }, + { 0x01eb, "\x00\x6f\x03\x28" }, + { 0x01ec, "\x01\xea\x03\x04" }, + { 0x01ed, "\x01\xeb\x03\x04" }, + { 0x01ee, "\x01\xb7\x03\x0c" }, + { 0x01ef, "\x02\x92\x03\x0c" }, + { 0x01f0, "\x00\x6a\x03\x0c" }, + { 0x01f4, "\x00\x47\x03\x01" }, + { 0x01f5, "\x00\x67\x03\x01" }, + { 0x01fa, "\x00\xc5\x03\x01" }, + { 0x01fb, "\x00\xe5\x03\x01" }, + { 0x01fc, "\x00\xc6\x03\x01" }, + { 0x01fd, "\x00\xe6\x03\x01" }, + { 0x01fe, "\x00\xd8\x03\x01" }, + { 0x01ff, "\x00\xf8\x03\x01" }, + { 0x0200, "\x00\x41\x03\x0f" }, + { 0x0201, "\x00\x61\x03\x0f" }, + { 0x0202, "\x00\x41\x03\x11" }, + { 0x0203, "\x00\x61\x03\x11" }, + { 0x0204, "\x00\x45\x03\x0f" }, + { 0x0205, "\x00\x65\x03\x0f" }, + { 0x0206, "\x00\x45\x03\x11" }, + { 0x0207, "\x00\x65\x03\x11" }, + { 0x0208, "\x00\x49\x03\x0f" }, + { 0x0209, "\x00\x69\x03\x0f" }, + { 0x020a, "\x00\x49\x03\x11" }, + { 0x020b, "\x00\x69\x03\x11" }, + { 0x020c, "\x00\x4f\x03\x0f" }, + { 0x020d, "\x00\x6f\x03\x0f" }, + { 0x020e, "\x00\x4f\x03\x11" }, + { 0x020f, "\x00\x6f\x03\x11" }, + { 0x0210, "\x00\x52\x03\x0f" }, + { 0x0211, "\x00\x72\x03\x0f" }, + { 0x0212, "\x00\x52\x03\x11" }, + { 0x0213, "\x00\x72\x03\x11" }, + { 0x0214, "\x00\x55\x03\x0f" }, + { 0x0215, "\x00\x75\x03\x0f" }, + { 0x0216, "\x00\x55\x03\x11" }, + { 0x0217, "\x00\x75\x03\x11" }, + { 0x0340, "\x03\x00" }, + { 0x0341, "\x03\x01" }, + { 0x0343, "\x03\x13" }, + { 0x0344, "\x03\x08\x03\x01" }, + { 0x0374, "\x02\xb9" }, + { 0x037e, "\x00\x3b" }, + { 0x0385, "\x00\xa8\x03\x01" }, + { 0x0386, "\x03\x91\x03\x01" }, + { 0x0387, "\x00\xb7" }, + { 0x0388, "\x03\x95\x03\x01" }, + { 0x0389, "\x03\x97\x03\x01" }, + { 0x038a, "\x03\x99\x03\x01" }, + { 0x038c, "\x03\x9f\x03\x01" }, + { 0x038e, "\x03\xa5\x03\x01" }, + { 0x038f, "\x03\xa9\x03\x01" }, + { 0x0390, "\x03\xca\x03\x01" }, + { 0x03aa, "\x03\x99\x03\x08" }, + { 0x03ab, "\x03\xa5\x03\x08" }, + { 0x03ac, "\x03\xb1\x03\x01" }, + { 0x03ad, "\x03\xb5\x03\x01" }, + { 0x03ae, "\x03\xb7\x03\x01" }, + { 0x03af, "\x03\xb9\x03\x01" }, + { 0x03b0, "\x03\xcb\x03\x01" }, + { 0x03ca, "\x03\xb9\x03\x08" }, + { 0x03cb, "\x03\xc5\x03\x08" }, + { 0x03cc, "\x03\xbf\x03\x01" }, + { 0x03cd, "\x03\xc5\x03\x01" }, + { 0x03ce, "\x03\xc9\x03\x01" }, + { 0x03d3, "\x03\xd2\x03\x01" }, + { 0x03d4, "\x03\xd2\x03\x08" }, + { 0x0401, "\x04\x15\x03\x08" }, + { 0x0403, "\x04\x13\x03\x01" }, + { 0x0407, "\x04\x06\x03\x08" }, + { 0x040c, "\x04\x1a\x03\x01" }, + { 0x040e, "\x04\x23\x03\x06" }, + { 0x0419, "\x04\x18\x03\x06" }, + { 0x0439, "\x04\x38\x03\x06" }, + { 0x0451, "\x04\x35\x03\x08" }, + { 0x0453, "\x04\x33\x03\x01" }, + { 0x0457, "\x04\x56\x03\x08" }, + { 0x045c, "\x04\x3a\x03\x01" }, + { 0x045e, "\x04\x43\x03\x06" }, + { 0x0476, "\x04\x74\x03\x0f" }, + { 0x0477, "\x04\x75\x03\x0f" }, + { 0x04c1, "\x04\x16\x03\x06" }, + { 0x04c2, "\x04\x36\x03\x06" }, + { 0x04d0, "\x04\x10\x03\x06" }, + { 0x04d1, "\x04\x30\x03\x06" }, + { 0x04d2, "\x04\x10\x03\x08" }, + { 0x04d3, "\x04\x30\x03\x08" }, + { 0x04d6, "\x04\x15\x03\x06" }, + { 0x04d7, "\x04\x35\x03\x06" }, + { 0x04da, "\x04\xd8\x03\x08" }, + { 0x04db, "\x04\xd9\x03\x08" }, + { 0x04dc, "\x04\x16\x03\x08" }, + { 0x04dd, "\x04\x36\x03\x08" }, + { 0x04de, "\x04\x17\x03\x08" }, + { 0x04df, "\x04\x37\x03\x08" }, + { 0x04e2, "\x04\x18\x03\x04" }, + { 0x04e3, "\x04\x38\x03\x04" }, + { 0x04e4, "\x04\x18\x03\x08" }, + { 0x04e5, "\x04\x38\x03\x08" }, + { 0x04e6, "\x04\x1e\x03\x08" }, + { 0x04e7, "\x04\x3e\x03\x08" }, + { 0x04ea, "\x04\xe8\x03\x08" }, + { 0x04eb, "\x04\xe9\x03\x08" }, + { 0x04ee, "\x04\x23\x03\x04" }, + { 0x04ef, "\x04\x43\x03\x04" }, + { 0x04f0, "\x04\x23\x03\x08" }, + { 0x04f1, "\x04\x43\x03\x08" }, + { 0x04f2, "\x04\x23\x03\x0b" }, + { 0x04f3, "\x04\x43\x03\x0b" }, + { 0x04f4, "\x04\x27\x03\x08" }, + { 0x04f5, "\x04\x47\x03\x08" }, + { 0x04f8, "\x04\x2b\x03\x08" }, + { 0x04f9, "\x04\x4b\x03\x08" }, + { 0x0929, "\x09\x28\x09\x3c" }, + { 0x0931, "\x09\x30\x09\x3c" }, + { 0x0934, "\x09\x33\x09\x3c" }, + { 0x0958, "\x09\x15\x09\x3c" }, + { 0x0959, "\x09\x16\x09\x3c" }, + { 0x095a, "\x09\x17\x09\x3c" }, + { 0x095b, "\x09\x1c\x09\x3c" }, + { 0x095c, "\x09\x21\x09\x3c" }, + { 0x095d, "\x09\x22\x09\x3c" }, + { 0x095e, "\x09\x2b\x09\x3c" }, + { 0x095f, "\x09\x2f\x09\x3c" }, + { 0x09b0, "\x09\xac\x09\xbc" }, + { 0x09cb, "\x09\xc7\x09\xbe" }, + { 0x09cc, "\x09\xc7\x09\xd7" }, + { 0x09dc, "\x09\xa1\x09\xbc" }, + { 0x09dd, "\x09\xa2\x09\xbc" }, + { 0x09df, "\x09\xaf\x09\xbc" }, + { 0x0a59, "\x0a\x16\x0a\x3c" }, + { 0x0a5a, "\x0a\x17\x0a\x3c" }, + { 0x0a5b, "\x0a\x1c\x0a\x3c" }, + { 0x0a5c, "\x0a\x21\x0a\x3c" }, + { 0x0a5e, "\x0a\x2b\x0a\x3c" }, + { 0x0b48, "\x0b\x47\x0b\x56" }, + { 0x0b4b, "\x0b\x47\x0b\x3e" }, + { 0x0b4c, "\x0b\x47\x0b\x57" }, + { 0x0b5c, "\x0b\x21\x0b\x3c" }, + { 0x0b5d, "\x0b\x22\x0b\x3c" }, + { 0x0b5f, "\x0b\x2f\x0b\x3c" }, + { 0x0b94, "\x0b\x92\x0b\xd7" }, + { 0x0bca, "\x0b\xc6\x0b\xbe" }, + { 0x0bcb, "\x0b\xc7\x0b\xbe" }, + { 0x0bcc, "\x0b\xc6\x0b\xd7" }, + { 0x0c48, "\x0c\x46\x0c\x56" }, + { 0x0cc0, "\x0c\xbf\x0c\xd5" }, + { 0x0cc7, "\x0c\xc6\x0c\xd5" }, + { 0x0cc8, "\x0c\xc6\x0c\xd6" }, + { 0x0cca, "\x0c\xc6\x0c\xc2" }, + { 0x0ccb, "\x0c\xca\x0c\xd5" }, + { 0x0d4a, "\x0d\x46\x0d\x3e" }, + { 0x0d4b, "\x0d\x47\x0d\x3e" }, + { 0x0d4c, "\x0d\x46\x0d\x57" }, + { 0x0e33, "\x0e\x4d\x0e\x32" }, + { 0x0eb3, "\x0e\xcd\x0e\xb2" }, + { 0x0f43, "\x0f\x42\x0f\xb7" }, + { 0x0f4d, "\x0f\x4c\x0f\xb7" }, + { 0x0f52, "\x0f\x51\x0f\xb7" }, + { 0x0f57, "\x0f\x56\x0f\xb7" }, + { 0x0f5c, "\x0f\x5b\x0f\xb7" }, + { 0x0f69, "\x0f\x40\x0f\xb5" }, + { 0x0f73, "\x0f\x72\x0f\x71" }, + { 0x0f75, "\x0f\x71\x0f\x74" }, + { 0x0f76, "\x0f\xb2\x0f\x80" }, + { 0x0f77, "\x0f\x76\x0f\x71" }, + { 0x0f78, "\x0f\xb3\x0f\x80" }, + { 0x0f79, "\x0f\x78\x0f\x71" }, + { 0x0f81, "\x0f\x80\x0f\x71" }, + { 0x0f93, "\x0f\x92\x0f\xb7" }, + { 0x0f9d, "\x0f\x9c\x0f\xb7" }, + { 0x0fa2, "\x0f\xa1\x0f\xb7" }, + { 0x0fa7, "\x0f\xa6\x0f\xb7" }, + { 0x0fac, "\x0f\xab\x0f\xb7" }, + { 0x0fb9, "\x0f\x90\x0f\xb5" }, + { 0x1e00, "\x00\x41\x03\x25" }, + { 0x1e01, "\x00\x61\x03\x25" }, + { 0x1e02, "\x00\x42\x03\x07" }, + { 0x1e03, "\x00\x62\x03\x07" }, + { 0x1e04, "\x00\x42\x03\x23" }, + { 0x1e05, "\x00\x62\x03\x23" }, + { 0x1e06, "\x00\x42\x03\x31" }, + { 0x1e07, "\x00\x62\x03\x31" }, + { 0x1e08, "\x00\xc7\x03\x01" }, + { 0x1e09, "\x00\xe7\x03\x01" }, + { 0x1e0a, "\x00\x44\x03\x07" }, + { 0x1e0b, "\x00\x64\x03\x07" }, + { 0x1e0c, "\x00\x44\x03\x23" }, + { 0x1e0d, "\x00\x64\x03\x23" }, + { 0x1e0e, "\x00\x44\x03\x31" }, + { 0x1e0f, "\x00\x64\x03\x31" }, + { 0x1e10, "\x00\x44\x03\x27" }, + { 0x1e11, "\x00\x64\x03\x27" }, + { 0x1e12, "\x00\x44\x03\x2d" }, + { 0x1e13, "\x00\x64\x03\x2d" }, + { 0x1e14, "\x01\x12\x03\x00" }, + { 0x1e15, "\x01\x13\x03\x00" }, + { 0x1e16, "\x01\x12\x03\x01" }, + { 0x1e17, "\x01\x13\x03\x01" }, + { 0x1e18, "\x00\x45\x03\x2d" }, + { 0x1e19, "\x00\x65\x03\x2d" }, + { 0x1e1a, "\x00\x45\x03\x30" }, + { 0x1e1b, "\x00\x65\x03\x30" }, + { 0x1e1c, "\x01\x14\x03\x27" }, + { 0x1e1d, "\x01\x15\x03\x27" }, + { 0x1e1e, "\x00\x46\x03\x07" }, + { 0x1e1f, "\x00\x66\x03\x07" }, + { 0x1e20, "\x00\x47\x03\x04" }, + { 0x1e21, "\x00\x67\x03\x04" }, + { 0x1e22, "\x00\x48\x03\x07" }, + { 0x1e23, "\x00\x68\x03\x07" }, + { 0x1e24, "\x00\x48\x03\x23" }, + { 0x1e25, "\x00\x68\x03\x23" }, + { 0x1e26, "\x00\x48\x03\x08" }, + { 0x1e27, "\x00\x68\x03\x08" }, + { 0x1e28, "\x00\x48\x03\x27" }, + { 0x1e29, "\x00\x68\x03\x27" }, + { 0x1e2a, "\x00\x48\x03\x2e" }, + { 0x1e2b, "\x00\x68\x03\x2e" }, + { 0x1e2c, "\x00\x49\x03\x30" }, + { 0x1e2d, "\x00\x69\x03\x30" }, + { 0x1e2e, "\x00\xcf\x03\x01" }, + { 0x1e2f, "\x00\xef\x03\x01" }, + { 0x1e30, "\x00\x4b\x03\x01" }, + { 0x1e31, "\x00\x6b\x03\x01" }, + { 0x1e32, "\x00\x4b\x03\x23" }, + { 0x1e33, "\x00\x6b\x03\x23" }, + { 0x1e34, "\x00\x4b\x03\x31" }, + { 0x1e35, "\x00\x6b\x03\x31" }, + { 0x1e36, "\x00\x4c\x03\x23" }, + { 0x1e37, "\x00\x6c\x03\x23" }, + { 0x1e38, "\x1e\x36\x03\x04" }, + { 0x1e39, "\x1e\x37\x03\x04" }, + { 0x1e3a, "\x00\x4c\x03\x31" }, + { 0x1e3b, "\x00\x6c\x03\x31" }, + { 0x1e3c, "\x00\x4c\x03\x2d" }, + { 0x1e3d, "\x00\x6c\x03\x2d" }, + { 0x1e3e, "\x00\x4d\x03\x01" }, + { 0x1e3f, "\x00\x6d\x03\x01" }, + { 0x1e40, "\x00\x4d\x03\x07" }, + { 0x1e41, "\x00\x6d\x03\x07" }, + { 0x1e42, "\x00\x4d\x03\x23" }, + { 0x1e43, "\x00\x6d\x03\x23" }, + { 0x1e44, "\x00\x4e\x03\x07" }, + { 0x1e45, "\x00\x6e\x03\x07" }, + { 0x1e46, "\x00\x4e\x03\x23" }, + { 0x1e47, "\x00\x6e\x03\x23" }, + { 0x1e48, "\x00\x4e\x03\x31" }, + { 0x1e49, "\x00\x6e\x03\x31" }, + { 0x1e4a, "\x00\x4e\x03\x2d" }, + { 0x1e4b, "\x00\x6e\x03\x2d" }, + { 0x1e4c, "\x00\xd5\x03\x01" }, + { 0x1e4d, "\x00\xf5\x03\x01" }, + { 0x1e4e, "\x00\xd5\x03\x08" }, + { 0x1e4f, "\x00\xf5\x03\x08" }, + { 0x1e50, "\x01\x4c\x03\x00" }, + { 0x1e51, "\x01\x4d\x03\x00" }, + { 0x1e52, "\x01\x4c\x03\x01" }, + { 0x1e53, "\x01\x4d\x03\x01" }, + { 0x1e54, "\x00\x50\x03\x01" }, + { 0x1e55, "\x00\x70\x03\x01" }, + { 0x1e56, "\x00\x50\x03\x07" }, + { 0x1e57, "\x00\x70\x03\x07" }, + { 0x1e58, "\x00\x52\x03\x07" }, + { 0x1e59, "\x00\x72\x03\x07" }, + { 0x1e5a, "\x00\x52\x03\x23" }, + { 0x1e5b, "\x00\x72\x03\x23" }, + { 0x1e5c, "\x1e\x5a\x03\x04" }, + { 0x1e5d, "\x1e\x5b\x03\x04" }, + { 0x1e5e, "\x00\x52\x03\x31" }, + { 0x1e5f, "\x00\x72\x03\x31" }, + { 0x1e60, "\x00\x53\x03\x07" }, + { 0x1e61, "\x00\x73\x03\x07" }, + { 0x1e62, "\x00\x53\x03\x23" }, + { 0x1e63, "\x00\x73\x03\x23" }, + { 0x1e64, "\x01\x5a\x03\x07" }, + { 0x1e65, "\x01\x5b\x03\x07" }, + { 0x1e66, "\x01\x60\x03\x07" }, + { 0x1e67, "\x01\x61\x03\x07" }, + { 0x1e68, "\x1e\x62\x03\x07" }, + { 0x1e69, "\x1e\x63\x03\x07" }, + { 0x1e6a, "\x00\x54\x03\x07" }, + { 0x1e6b, "\x00\x74\x03\x07" }, + { 0x1e6c, "\x00\x54\x03\x23" }, + { 0x1e6d, "\x00\x74\x03\x23" }, + { 0x1e6e, "\x00\x54\x03\x31" }, + { 0x1e6f, "\x00\x74\x03\x31" }, + { 0x1e70, "\x00\x54\x03\x2d" }, + { 0x1e71, "\x00\x74\x03\x2d" }, + { 0x1e72, "\x00\x55\x03\x24" }, + { 0x1e73, "\x00\x75\x03\x24" }, + { 0x1e74, "\x00\x55\x03\x30" }, + { 0x1e75, "\x00\x75\x03\x30" }, + { 0x1e76, "\x00\x55\x03\x2d" }, + { 0x1e77, "\x00\x75\x03\x2d" }, + { 0x1e78, "\x01\x68\x03\x01" }, + { 0x1e79, "\x01\x69\x03\x01" }, + { 0x1e7a, "\x01\x6a\x03\x08" }, + { 0x1e7b, "\x01\x6b\x03\x08" }, + { 0x1e7c, "\x00\x56\x03\x03" }, + { 0x1e7d, "\x00\x76\x03\x03" }, + { 0x1e7e, "\x00\x56\x03\x23" }, + { 0x1e7f, "\x00\x76\x03\x23" }, + { 0x1e80, "\x00\x57\x03\x00" }, + { 0x1e81, "\x00\x77\x03\x00" }, + { 0x1e82, "\x00\x57\x03\x01" }, + { 0x1e83, "\x00\x77\x03\x01" }, + { 0x1e84, "\x00\x57\x03\x08" }, + { 0x1e85, "\x00\x77\x03\x08" }, + { 0x1e86, "\x00\x57\x03\x07" }, + { 0x1e87, "\x00\x77\x03\x07" }, + { 0x1e88, "\x00\x57\x03\x23" }, + { 0x1e89, "\x00\x77\x03\x23" }, + { 0x1e8a, "\x00\x58\x03\x07" }, + { 0x1e8b, "\x00\x78\x03\x07" }, + { 0x1e8c, "\x00\x58\x03\x08" }, + { 0x1e8d, "\x00\x78\x03\x08" }, + { 0x1e8e, "\x00\x59\x03\x07" }, + { 0x1e8f, "\x00\x79\x03\x07" }, + { 0x1e90, "\x00\x5a\x03\x02" }, + { 0x1e91, "\x00\x7a\x03\x02" }, + { 0x1e92, "\x00\x5a\x03\x23" }, + { 0x1e93, "\x00\x7a\x03\x23" }, + { 0x1e94, "\x00\x5a\x03\x31" }, + { 0x1e95, "\x00\x7a\x03\x31" }, + { 0x1e96, "\x00\x68\x03\x31" }, + { 0x1e97, "\x00\x74\x03\x08" }, + { 0x1e98, "\x00\x77\x03\x0a" }, + { 0x1e99, "\x00\x79\x03\x0a" }, + { 0x1e9b, "\x01\x7f\x03\x07" }, + { 0x1ea0, "\x00\x41\x03\x23" }, + { 0x1ea1, "\x00\x61\x03\x23" }, + { 0x1ea2, "\x00\x41\x03\x09" }, + { 0x1ea3, "\x00\x61\x03\x09" }, + { 0x1ea4, "\x00\xc2\x03\x01" }, + { 0x1ea5, "\x00\xe2\x03\x01" }, + { 0x1ea6, "\x00\xc2\x03\x00" }, + { 0x1ea7, "\x00\xe2\x03\x00" }, + { 0x1ea8, "\x00\xc2\x03\x09" }, + { 0x1ea9, "\x00\xe2\x03\x09" }, + { 0x1eaa, "\x00\xc2\x03\x03" }, + { 0x1eab, "\x00\xe2\x03\x03" }, + { 0x1eac, "\x00\xc2\x03\x23" }, + { 0x1ead, "\x00\xe2\x03\x23" }, + { 0x1eae, "\x01\x02\x03\x01" }, + { 0x1eaf, "\x01\x03\x03\x01" }, + { 0x1eb0, "\x01\x02\x03\x00" }, + { 0x1eb1, "\x01\x03\x03\x00" }, + { 0x1eb2, "\x01\x02\x03\x09" }, + { 0x1eb3, "\x01\x03\x03\x09" }, + { 0x1eb4, "\x01\x02\x03\x03" }, + { 0x1eb5, "\x01\x03\x03\x03" }, + { 0x1eb6, "\x01\x02\x03\x23" }, + { 0x1eb7, "\x01\x03\x03\x23" }, + { 0x1eb8, "\x00\x45\x03\x23" }, + { 0x1eb9, "\x00\x65\x03\x23" }, + { 0x1eba, "\x00\x45\x03\x09" }, + { 0x1ebb, "\x00\x65\x03\x09" }, + { 0x1ebc, "\x00\x45\x03\x03" }, + { 0x1ebd, "\x00\x65\x03\x03" }, + { 0x1ebe, "\x00\xca\x03\x01" }, + { 0x1ebf, "\x00\xea\x03\x01" }, + { 0x1ec0, "\x00\xca\x03\x00" }, + { 0x1ec1, "\x00\xea\x03\x00" }, + { 0x1ec2, "\x00\xca\x03\x09" }, + { 0x1ec3, "\x00\xea\x03\x09" }, + { 0x1ec4, "\x00\xca\x03\x03" }, + { 0x1ec5, "\x00\xea\x03\x03" }, + { 0x1ec6, "\x00\xca\x03\x23" }, + { 0x1ec7, "\x00\xea\x03\x23" }, + { 0x1ec8, "\x00\x49\x03\x09" }, + { 0x1ec9, "\x00\x69\x03\x09" }, + { 0x1eca, "\x00\x49\x03\x23" }, + { 0x1ecb, "\x00\x69\x03\x23" }, + { 0x1ecc, "\x00\x4f\x03\x23" }, + { 0x1ecd, "\x00\x6f\x03\x23" }, + { 0x1ece, "\x00\x4f\x03\x09" }, + { 0x1ecf, "\x00\x6f\x03\x09" }, + { 0x1ed0, "\x00\xd4\x03\x01" }, + { 0x1ed1, "\x00\xf4\x03\x01" }, + { 0x1ed2, "\x00\xd4\x03\x00" }, + { 0x1ed3, "\x00\xf4\x03\x00" }, + { 0x1ed4, "\x00\xd4\x03\x09" }, + { 0x1ed5, "\x00\xf4\x03\x09" }, + { 0x1ed6, "\x00\xd4\x03\x03" }, + { 0x1ed7, "\x00\xf4\x03\x03" }, + { 0x1ed8, "\x00\xd4\x03\x23" }, + { 0x1ed9, "\x00\xf4\x03\x23" }, + { 0x1eda, "\x01\xa0\x03\x01" }, + { 0x1edb, "\x01\xa1\x03\x01" }, + { 0x1edc, "\x01\xa0\x03\x00" }, + { 0x1edd, "\x01\xa1\x03\x00" }, + { 0x1ede, "\x01\xa0\x03\x09" }, + { 0x1edf, "\x01\xa1\x03\x09" }, + { 0x1ee0, "\x01\xa0\x03\x03" }, + { 0x1ee1, "\x01\xa1\x03\x03" }, + { 0x1ee2, "\x01\xa0\x03\x23" }, + { 0x1ee3, "\x01\xa1\x03\x23" }, + { 0x1ee4, "\x00\x55\x03\x23" }, + { 0x1ee5, "\x00\x75\x03\x23" }, + { 0x1ee6, "\x00\x55\x03\x09" }, + { 0x1ee7, "\x00\x75\x03\x09" }, + { 0x1ee8, "\x01\xaf\x03\x01" }, + { 0x1ee9, "\x01\xb0\x03\x01" }, + { 0x1eea, "\x01\xaf\x03\x00" }, + { 0x1eeb, "\x01\xb0\x03\x00" }, + { 0x1eec, "\x01\xaf\x03\x09" }, + { 0x1eed, "\x01\xb0\x03\x09" }, + { 0x1eee, "\x01\xaf\x03\x03" }, + { 0x1eef, "\x01\xb0\x03\x03" }, + { 0x1ef0, "\x01\xaf\x03\x23" }, + { 0x1ef1, "\x01\xb0\x03\x23" }, + { 0x1ef2, "\x00\x59\x03\x00" }, + { 0x1ef3, "\x00\x79\x03\x00" }, + { 0x1ef4, "\x00\x59\x03\x23" }, + { 0x1ef5, "\x00\x79\x03\x23" }, + { 0x1ef6, "\x00\x59\x03\x09" }, + { 0x1ef7, "\x00\x79\x03\x09" }, + { 0x1ef8, "\x00\x59\x03\x03" }, + { 0x1ef9, "\x00\x79\x03\x03" }, + { 0x1f00, "\x03\xb1\x03\x13" }, + { 0x1f01, "\x03\xb1\x03\x14" }, + { 0x1f02, "\x1f\x00\x03\x00" }, + { 0x1f03, "\x1f\x01\x03\x00" }, + { 0x1f04, "\x1f\x00\x03\x01" }, + { 0x1f05, "\x1f\x01\x03\x01" }, + { 0x1f06, "\x1f\x00\x03\x42" }, + { 0x1f07, "\x1f\x01\x03\x42" }, + { 0x1f08, "\x03\x91\x03\x13" }, + { 0x1f09, "\x03\x91\x03\x14" }, + { 0x1f0a, "\x1f\x08\x03\x00" }, + { 0x1f0b, "\x1f\x09\x03\x00" }, + { 0x1f0c, "\x1f\x08\x03\x01" }, + { 0x1f0d, "\x1f\x09\x03\x01" }, + { 0x1f0e, "\x1f\x08\x03\x42" }, + { 0x1f0f, "\x1f\x09\x03\x42" }, + { 0x1f10, "\x03\xb5\x03\x13" }, + { 0x1f11, "\x03\xb5\x03\x14" }, + { 0x1f12, "\x1f\x10\x03\x00" }, + { 0x1f13, "\x1f\x11\x03\x00" }, + { 0x1f14, "\x1f\x10\x03\x01" }, + { 0x1f15, "\x1f\x11\x03\x01" }, + { 0x1f18, "\x03\x95\x03\x13" }, + { 0x1f19, "\x03\x95\x03\x14" }, + { 0x1f1a, "\x1f\x18\x03\x00" }, + { 0x1f1b, "\x1f\x19\x03\x00" }, + { 0x1f1c, "\x1f\x18\x03\x01" }, + { 0x1f1d, "\x1f\x19\x03\x01" }, + { 0x1f20, "\x03\xb7\x03\x13" }, + { 0x1f21, "\x03\xb7\x03\x14" }, + { 0x1f22, "\x1f\x20\x03\x00" }, + { 0x1f23, "\x1f\x21\x03\x00" }, + { 0x1f24, "\x1f\x20\x03\x01" }, + { 0x1f25, "\x1f\x21\x03\x01" }, + { 0x1f26, "\x1f\x20\x03\x42" }, + { 0x1f27, "\x1f\x21\x03\x42" }, + { 0x1f28, "\x03\x97\x03\x13" }, + { 0x1f29, "\x03\x97\x03\x14" }, + { 0x1f2a, "\x1f\x28\x03\x00" }, + { 0x1f2b, "\x1f\x29\x03\x00" }, + { 0x1f2c, "\x1f\x28\x03\x01" }, + { 0x1f2d, "\x1f\x29\x03\x01" }, + { 0x1f2e, "\x1f\x28\x03\x42" }, + { 0x1f2f, "\x1f\x29\x03\x42" }, + { 0x1f30, "\x03\xb9\x03\x13" }, + { 0x1f31, "\x03\xb9\x03\x14" }, + { 0x1f32, "\x1f\x30\x03\x00" }, + { 0x1f33, "\x1f\x31\x03\x00" }, + { 0x1f34, "\x1f\x30\x03\x01" }, + { 0x1f35, "\x1f\x31\x03\x01" }, + { 0x1f36, "\x1f\x30\x03\x42" }, + { 0x1f37, "\x1f\x31\x03\x42" }, + { 0x1f38, "\x03\x99\x03\x13" }, + { 0x1f39, "\x03\x99\x03\x14" }, + { 0x1f3a, "\x1f\x38\x03\x00" }, + { 0x1f3b, "\x1f\x39\x03\x00" }, + { 0x1f3c, "\x1f\x38\x03\x01" }, + { 0x1f3d, "\x1f\x39\x03\x01" }, + { 0x1f3e, "\x1f\x38\x03\x42" }, + { 0x1f3f, "\x1f\x39\x03\x42" }, + { 0x1f40, "\x03\xbf\x03\x13" }, + { 0x1f41, "\x03\xbf\x03\x14" }, + { 0x1f42, "\x1f\x40\x03\x00" }, + { 0x1f43, "\x1f\x41\x03\x00" }, + { 0x1f44, "\x1f\x40\x03\x01" }, + { 0x1f45, "\x1f\x41\x03\x01" }, + { 0x1f48, "\x03\x9f\x03\x13" }, + { 0x1f49, "\x03\x9f\x03\x14" }, + { 0x1f4a, "\x1f\x48\x03\x00" }, + { 0x1f4b, "\x1f\x49\x03\x00" }, + { 0x1f4c, "\x1f\x48\x03\x01" }, + { 0x1f4d, "\x1f\x49\x03\x01" }, + { 0x1f50, "\x03\xc5\x03\x13" }, + { 0x1f51, "\x03\xc5\x03\x14" }, + { 0x1f52, "\x1f\x50\x03\x00" }, + { 0x1f53, "\x1f\x51\x03\x00" }, + { 0x1f54, "\x1f\x50\x03\x01" }, + { 0x1f55, "\x1f\x51\x03\x01" }, + { 0x1f56, "\x1f\x50\x03\x42" }, + { 0x1f57, "\x1f\x51\x03\x42" }, + { 0x1f59, "\x03\xa5\x03\x14" }, + { 0x1f5b, "\x1f\x59\x03\x00" }, + { 0x1f5d, "\x1f\x59\x03\x01" }, + { 0x1f5f, "\x1f\x59\x03\x42" }, + { 0x1f60, "\x03\xc9\x03\x13" }, + { 0x1f61, "\x03\xc9\x03\x14" }, + { 0x1f62, "\x1f\x60\x03\x00" }, + { 0x1f63, "\x1f\x61\x03\x00" }, + { 0x1f64, "\x1f\x60\x03\x01" }, + { 0x1f65, "\x1f\x61\x03\x01" }, + { 0x1f66, "\x1f\x60\x03\x42" }, + { 0x1f67, "\x1f\x61\x03\x42" }, + { 0x1f68, "\x03\xa9\x03\x13" }, + { 0x1f69, "\x03\xa9\x03\x14" }, + { 0x1f6a, "\x1f\x68\x03\x00" }, + { 0x1f6b, "\x1f\x69\x03\x00" }, + { 0x1f6c, "\x1f\x68\x03\x01" }, + { 0x1f6d, "\x1f\x69\x03\x01" }, + { 0x1f6e, "\x1f\x68\x03\x42" }, + { 0x1f6f, "\x1f\x69\x03\x42" }, + { 0x1f70, "\x03\xb1\x03\x00" }, + { 0x1f71, "\x03\xac" }, + { 0x1f72, "\x03\xb5\x03\x00" }, + { 0x1f73, "\x03\xad" }, + { 0x1f74, "\x03\xb7\x03\x00" }, + { 0x1f75, "\x03\xae" }, + { 0x1f76, "\x03\xb9\x03\x00" }, + { 0x1f77, "\x03\xaf" }, + { 0x1f78, "\x03\xbf\x03\x00" }, + { 0x1f79, "\x03\xcc" }, + { 0x1f7a, "\x03\xc5\x03\x00" }, + { 0x1f7b, "\x03\xcd" }, + { 0x1f7c, "\x03\xc9\x03\x00" }, + { 0x1f7d, "\x03\xce" }, + { 0x1f80, "\x1f\x00\x03\x45" }, + { 0x1f81, "\x1f\x01\x03\x45" }, + { 0x1f82, "\x1f\x02\x03\x45" }, + { 0x1f83, "\x1f\x03\x03\x45" }, + { 0x1f84, "\x1f\x04\x03\x45" }, + { 0x1f85, "\x1f\x05\x03\x45" }, + { 0x1f86, "\x1f\x06\x03\x45" }, + { 0x1f87, "\x1f\x07\x03\x45" }, + { 0x1f88, "\x1f\x08\x03\x45" }, + { 0x1f89, "\x1f\x09\x03\x45" }, + { 0x1f8a, "\x1f\x0a\x03\x45" }, + { 0x1f8b, "\x1f\x0b\x03\x45" }, + { 0x1f8c, "\x1f\x0c\x03\x45" }, + { 0x1f8d, "\x1f\x0d\x03\x45" }, + { 0x1f8e, "\x1f\x0e\x03\x45" }, + { 0x1f8f, "\x1f\x0f\x03\x45" }, + { 0x1f90, "\x1f\x20\x03\x45" }, + { 0x1f91, "\x1f\x21\x03\x45" }, + { 0x1f92, "\x1f\x22\x03\x45" }, + { 0x1f93, "\x1f\x23\x03\x45" }, + { 0x1f94, "\x1f\x24\x03\x45" }, + { 0x1f95, "\x1f\x25\x03\x45" }, + { 0x1f96, "\x1f\x26\x03\x45" }, + { 0x1f97, "\x1f\x27\x03\x45" }, + { 0x1f98, "\x1f\x28\x03\x45" }, + { 0x1f99, "\x1f\x29\x03\x45" }, + { 0x1f9a, "\x1f\x2a\x03\x45" }, + { 0x1f9b, "\x1f\x2b\x03\x45" }, + { 0x1f9c, "\x1f\x2c\x03\x45" }, + { 0x1f9d, "\x1f\x2d\x03\x45" }, + { 0x1f9e, "\x1f\x2e\x03\x45" }, + { 0x1f9f, "\x1f\x2f\x03\x45" }, + { 0x1fa0, "\x1f\x60\x03\x45" }, + { 0x1fa1, "\x1f\x61\x03\x45" }, + { 0x1fa2, "\x1f\x62\x03\x45" }, + { 0x1fa3, "\x1f\x63\x03\x45" }, + { 0x1fa4, "\x1f\x64\x03\x45" }, + { 0x1fa5, "\x1f\x65\x03\x45" }, + { 0x1fa6, "\x1f\x66\x03\x45" }, + { 0x1fa7, "\x1f\x67\x03\x45" }, + { 0x1fa8, "\x1f\x68\x03\x45" }, + { 0x1fa9, "\x1f\x69\x03\x45" }, + { 0x1faa, "\x1f\x6a\x03\x45" }, + { 0x1fab, "\x1f\x6b\x03\x45" }, + { 0x1fac, "\x1f\x6c\x03\x45" }, + { 0x1fad, "\x1f\x6d\x03\x45" }, + { 0x1fae, "\x1f\x6e\x03\x45" }, + { 0x1faf, "\x1f\x6f\x03\x45" }, + { 0x1fb0, "\x03\xb1\x03\x06" }, + { 0x1fb1, "\x03\xb1\x03\x04" }, + { 0x1fb2, "\x1f\x70\x03\x45" }, + { 0x1fb3, "\x03\xb1\x03\x45" }, + { 0x1fb4, "\x03\xac\x03\x45" }, + { 0x1fb6, "\x03\xb1\x03\x42" }, + { 0x1fb7, "\x1f\xb6\x03\x45" }, + { 0x1fb8, "\x03\x91\x03\x06" }, + { 0x1fb9, "\x03\x91\x03\x04" }, + { 0x1fba, "\x03\x91\x03\x00" }, + { 0x1fbb, "\x03\x86" }, + { 0x1fbc, "\x03\x91\x03\x45" }, + { 0x1fbe, "\x03\xb9" }, + { 0x1fc1, "\x00\xa8\x03\x42" }, + { 0x1fc2, "\x1f\x74\x03\x45" }, + { 0x1fc3, "\x03\xb7\x03\x45" }, + { 0x1fc4, "\x03\xae\x03\x45" }, + { 0x1fc6, "\x03\xb7\x03\x42" }, + { 0x1fc7, "\x1f\xc6\x03\x45" }, + { 0x1fc8, "\x03\x95\x03\x00" }, + { 0x1fc9, "\x03\x88" }, + { 0x1fca, "\x03\x97\x03\x00" }, + { 0x1fcb, "\x03\x89" }, + { 0x1fcc, "\x03\x97\x03\x45" }, + { 0x1fcd, "\x1f\xbf\x03\x00" }, + { 0x1fce, "\x1f\xbf\x03\x01" }, + { 0x1fcf, "\x1f\xbf\x03\x42" }, + { 0x1fd0, "\x03\xb9\x03\x06" }, + { 0x1fd1, "\x03\xb9\x03\x04" }, + { 0x1fd2, "\x03\xca\x03\x00" }, + { 0x1fd3, "\x03\x90" }, + { 0x1fd6, "\x03\xb9\x03\x42" }, + { 0x1fd7, "\x03\xca\x03\x42" }, + { 0x1fd8, "\x03\x99\x03\x06" }, + { 0x1fd9, "\x03\x99\x03\x04" }, + { 0x1fda, "\x03\x99\x03\x00" }, + { 0x1fdb, "\x03\x8a" }, + { 0x1fdd, "\x1f\xfe\x03\x00" }, + { 0x1fde, "\x1f\xfe\x03\x01" }, + { 0x1fdf, "\x1f\xfe\x03\x42" }, + { 0x1fe0, "\x03\xc5\x03\x06" }, + { 0x1fe1, "\x03\xc5\x03\x04" }, + { 0x1fe2, "\x03\xcb\x03\x00" }, + { 0x1fe3, "\x03\xb0" }, + { 0x1fe4, "\x03\xc1\x03\x13" }, + { 0x1fe5, "\x03\xc1\x03\x14" }, + { 0x1fe6, "\x03\xc5\x03\x42" }, + { 0x1fe7, "\x03\xcb\x03\x42" }, + { 0x1fe8, "\x03\xa5\x03\x06" }, + { 0x1fe9, "\x03\xa5\x03\x04" }, + { 0x1fea, "\x03\xa5\x03\x00" }, + { 0x1feb, "\x03\x8e" }, + { 0x1fec, "\x03\xa1\x03\x14" }, + { 0x1fed, "\x00\xa8\x03\x00" }, + { 0x1fee, "\x03\x85" }, + { 0x1fef, "\x00\x60" }, + { 0x1ff2, "\x1f\x7c\x03\x45" }, + { 0x1ff3, "\x03\xc9\x03\x45" }, + { 0x1ff4, "\x03\xce\x03\x45" }, + { 0x1ff6, "\x03\xc9\x03\x42" }, + { 0x1ff7, "\x1f\xf6\x03\x45" }, + { 0x1ff8, "\x03\x9f\x03\x00" }, + { 0x1ff9, "\x03\x8c" }, + { 0x1ffa, "\x03\xa9\x03\x00" }, + { 0x1ffb, "\x03\x8f" }, + { 0x1ffc, "\x03\xa9\x03\x45" }, + { 0x1ffd, "\x00\xb4" }, + { 0x2000, "\x20\x02" }, + { 0x2001, "\x20\x03" }, + { 0x2126, "\x03\xa9" }, + { 0x212a, "\x00\x4b" }, + { 0x212b, "\x00\xc5" }, + { 0x2204, "\x22\x03\x03\x38" }, + { 0x2209, "\x22\x08\x03\x38" }, + { 0x220c, "\x22\x0b\x03\x38" }, + { 0x2224, "\x22\x23\x03\x38" }, + { 0x2226, "\x22\x25\x03\x38" }, + { 0x2241, "\x00\x7e\x03\x38" }, + { 0x2244, "\x22\x43\x03\x38" }, + { 0x2247, "\x22\x45\x03\x38" }, + { 0x2249, "\x22\x48\x03\x38" }, + { 0x2260, "\x00\x3d\x03\x38" }, + { 0x2262, "\x22\x61\x03\x38" }, + { 0x226d, "\x22\x4d\x03\x38" }, + { 0x226e, "\x00\x3c\x03\x38" }, + { 0x226f, "\x00\x3e\x03\x38" }, + { 0x2270, "\x22\x64\x03\x38" }, + { 0x2271, "\x22\x65\x03\x38" }, + { 0x2274, "\x22\x72\x03\x38" }, + { 0x2275, "\x22\x73\x03\x38" }, + { 0x2278, "\x22\x76\x03\x38" }, + { 0x2279, "\x22\x77\x03\x38" }, + { 0x2280, "\x22\x7a\x03\x38" }, + { 0x2281, "\x22\x7b\x03\x38" }, + { 0x2284, "\x22\x82\x03\x38" }, + { 0x2285, "\x22\x83\x03\x38" }, + { 0x2288, "\x22\x86\x03\x38" }, + { 0x2289, "\x22\x87\x03\x38" }, + { 0x22ac, "\x22\xa2\x03\x38" }, + { 0x22ad, "\x22\xa8\x03\x38" }, + { 0x22ae, "\x22\xa9\x03\x38" }, + { 0x22af, "\x22\xab\x03\x38" }, + { 0x22e0, "\x22\x7c\x03\x38" }, + { 0x22e1, "\x22\x7d\x03\x38" }, + { 0x22e2, "\x22\x91\x03\x38" }, + { 0x22e3, "\x22\x92\x03\x38" }, + { 0x22ea, "\x22\xb2\x03\x38" }, + { 0x22eb, "\x22\xb3\x03\x38" }, + { 0x22ec, "\x22\xb4\x03\x38" }, + { 0x22ed, "\x22\xb5\x03\x38" }, + { 0x2329, "\x30\x08" }, + { 0x232a, "\x30\x09" }, + { 0x304c, "\x30\x4b\x30\x99" }, + { 0x304e, "\x30\x4d\x30\x99" }, + { 0x3050, "\x30\x4f\x30\x99" }, + { 0x3052, "\x30\x51\x30\x99" }, + { 0x3054, "\x30\x53\x30\x99" }, + { 0x3056, "\x30\x55\x30\x99" }, + { 0x3058, "\x30\x57\x30\x99" }, + { 0x305a, "\x30\x59\x30\x99" }, + { 0x305c, "\x30\x5b\x30\x99" }, + { 0x305e, "\x30\x5d\x30\x99" }, + { 0x3060, "\x30\x5f\x30\x99" }, + { 0x3062, "\x30\x61\x30\x99" }, + { 0x3065, "\x30\x64\x30\x99" }, + { 0x3067, "\x30\x66\x30\x99" }, + { 0x3069, "\x30\x68\x30\x99" }, + { 0x3070, "\x30\x6f\x30\x99" }, + { 0x3071, "\x30\x6f\x30\x9a" }, + { 0x3073, "\x30\x72\x30\x99" }, + { 0x3074, "\x30\x72\x30\x9a" }, + { 0x3076, "\x30\x75\x30\x99" }, + { 0x3077, "\x30\x75\x30\x9a" }, + { 0x3079, "\x30\x78\x30\x99" }, + { 0x307a, "\x30\x78\x30\x9a" }, + { 0x307c, "\x30\x7b\x30\x99" }, + { 0x307d, "\x30\x7b\x30\x9a" }, + { 0x3094, "\x30\x46\x30\x99" }, + { 0x309e, "\x30\x9d\x30\x99" }, + { 0x30ac, "\x30\xab\x30\x99" }, + { 0x30ae, "\x30\xad\x30\x99" }, + { 0x30b0, "\x30\xaf\x30\x99" }, + { 0x30b2, "\x30\xb1\x30\x99" }, + { 0x30b4, "\x30\xb3\x30\x99" }, + { 0x30b6, "\x30\xb5\x30\x99" }, + { 0x30b8, "\x30\xb7\x30\x99" }, + { 0x30ba, "\x30\xb9\x30\x99" }, + { 0x30bc, "\x30\xbb\x30\x99" }, + { 0x30be, "\x30\xbd\x30\x99" }, + { 0x30c0, "\x30\xbf\x30\x99" }, + { 0x30c2, "\x30\xc1\x30\x99" }, + { 0x30c5, "\x30\xc4\x30\x99" }, + { 0x30c7, "\x30\xc6\x30\x99" }, + { 0x30c9, "\x30\xc8\x30\x99" }, + { 0x30d0, "\x30\xcf\x30\x99" }, + { 0x30d1, "\x30\xcf\x30\x9a" }, + { 0x30d3, "\x30\xd2\x30\x99" }, + { 0x30d4, "\x30\xd2\x30\x9a" }, + { 0x30d6, "\x30\xd5\x30\x99" }, + { 0x30d7, "\x30\xd5\x30\x9a" }, + { 0x30d9, "\x30\xd8\x30\x99" }, + { 0x30da, "\x30\xd8\x30\x9a" }, + { 0x30dc, "\x30\xdb\x30\x99" }, + { 0x30dd, "\x30\xdb\x30\x9a" }, + { 0x30f4, "\x30\xa6\x30\x99" }, + { 0x30f7, "\x30\xef\x30\x99" }, + { 0x30f8, "\x30\xf0\x30\x99" }, + { 0x30f9, "\x30\xf1\x30\x99" }, + { 0x30fa, "\x30\xf2\x30\x99" }, + { 0x30fe, "\x30\xfd\x30\x99" }, + { 0xf900, "\x8c\x48" }, + { 0xf901, "\x66\xf4" }, + { 0xf902, "\x8e\xca" }, + { 0xf903, "\x8c\xc8" }, + { 0xf904, "\x6e\xd1" }, + { 0xf905, "\x4e\x32" }, + { 0xf906, "\x53\xe5" }, + { 0xf907, "\x9f\x9c" }, + { 0xf908, "\x9f\x9c" }, + { 0xf909, "\x59\x51" }, + { 0xf90a, "\x91\xd1" }, + { 0xf90b, "\x55\x87" }, + { 0xf90c, "\x59\x48" }, + { 0xf90d, "\x61\xf6" }, + { 0xf90e, "\x76\x69" }, + { 0xf90f, "\x7f\x85" }, + { 0xf910, "\x86\x3f" }, + { 0xf911, "\x87\xba" }, + { 0xf912, "\x88\xf8" }, + { 0xf913, "\x90\x8f" }, + { 0xf914, "\x6a\x02" }, + { 0xf915, "\x6d\x1b" }, + { 0xf916, "\x70\xd9" }, + { 0xf917, "\x73\xde" }, + { 0xf918, "\x84\x3d" }, + { 0xf919, "\x91\x6a" }, + { 0xf91a, "\x99\xf1" }, + { 0xf91b, "\x4e\x82" }, + { 0xf91c, "\x53\x75" }, + { 0xf91d, "\x6b\x04" }, + { 0xf91e, "\x72\x1b" }, + { 0xf91f, "\x86\x2d" }, + { 0xf920, "\x9e\x1e" }, + { 0xf921, "\x5d\x50" }, + { 0xf922, "\x6f\xeb" }, + { 0xf923, "\x85\xcd" }, + { 0xf924, "\x89\x64" }, + { 0xf925, "\x62\xc9" }, + { 0xf926, "\x81\xd8" }, + { 0xf927, "\x88\x1f" }, + { 0xf928, "\x5e\xca" }, + { 0xf929, "\x67\x17" }, + { 0xf92a, "\x6d\x6a" }, + { 0xf92b, "\x72\xfc" }, + { 0xf92c, "\x90\xce" }, + { 0xf92d, "\x4f\x86" }, + { 0xf92e, "\x51\xb7" }, + { 0xf92f, "\x52\xde" }, + { 0xf930, "\x64\xc4" }, + { 0xf931, "\x6a\xd3" }, + { 0xf932, "\x72\x10" }, + { 0xf933, "\x76\xe7" }, + { 0xf934, "\x80\x01" }, + { 0xf935, "\x86\x06" }, + { 0xf936, "\x86\x5c" }, + { 0xf937, "\x8d\xef" }, + { 0xf938, "\x97\x32" }, + { 0xf939, "\x9b\x6f" }, + { 0xf93a, "\x9d\xfa" }, + { 0xf93b, "\x78\x8c" }, + { 0xf93c, "\x79\x7f" }, + { 0xf93d, "\x7d\xa0" }, + { 0xf93e, "\x83\xc9" }, + { 0xf93f, "\x93\x04" }, + { 0xf940, "\x9e\x7f" }, + { 0xf941, "\x8a\xd6" }, + { 0xf942, "\x58\xdf" }, + { 0xf943, "\x5f\x04" }, + { 0xf944, "\x7c\x60" }, + { 0xf945, "\x80\x7e" }, + { 0xf946, "\x72\x62" }, + { 0xf947, "\x78\xca" }, + { 0xf948, "\x8c\xc2" }, + { 0xf949, "\x96\xf7" }, + { 0xf94a, "\x58\xd8" }, + { 0xf94b, "\x5c\x62" }, + { 0xf94c, "\x6a\x13" }, + { 0xf94d, "\x6d\xda" }, + { 0xf94e, "\x6f\x0f" }, + { 0xf94f, "\x7d\x2f" }, + { 0xf950, "\x7e\x37" }, + { 0xf951, "\x96\xfb" }, + { 0xf952, "\x52\xd2" }, + { 0xf953, "\x80\x8b" }, + { 0xf954, "\x51\xdc" }, + { 0xf955, "\x51\xcc" }, + { 0xf956, "\x7a\x1c" }, + { 0xf957, "\x7d\xbe" }, + { 0xf958, "\x83\xf1" }, + { 0xf959, "\x96\x75" }, + { 0xf95a, "\x8b\x80" }, + { 0xf95b, "\x62\xcf" }, + { 0xf95c, "\x6a\x02" }, + { 0xf95d, "\x8a\xfe" }, + { 0xf95e, "\x4e\x39" }, + { 0xf95f, "\x5b\xe7" }, + { 0xf960, "\x60\x12" }, + { 0xf961, "\x73\x87" }, + { 0xf962, "\x75\x70" }, + { 0xf963, "\x53\x17" }, + { 0xf964, "\x78\xfb" }, + { 0xf965, "\x4f\xbf" }, + { 0xf966, "\x5f\xa9" }, + { 0xf967, "\x4e\x0d" }, + { 0xf968, "\x6c\xcc" }, + { 0xf969, "\x65\x78" }, + { 0xf96a, "\x7d\x22" }, + { 0xf96b, "\x53\xc3" }, + { 0xf96c, "\x58\x5e" }, + { 0xf96d, "\x77\x01" }, + { 0xf96e, "\x84\x49" }, + { 0xf96f, "\x8a\xaa" }, + { 0xf970, "\x6b\xba" }, + { 0xf971, "\x8f\xb0" }, + { 0xf972, "\x6c\x88" }, + { 0xf973, "\x62\xfe" }, + { 0xf974, "\x82\xe5" }, + { 0xf975, "\x63\xa0" }, + { 0xf976, "\x75\x65" }, + { 0xf977, "\x4e\xae" }, + { 0xf978, "\x51\x69" }, + { 0xf979, "\x51\xc9" }, + { 0xf97a, "\x68\x81" }, + { 0xf97b, "\x7c\xe7" }, + { 0xf97c, "\x82\x6f" }, + { 0xf97d, "\x8a\xd2" }, + { 0xf97e, "\x91\xcf" }, + { 0xf97f, "\x52\xf5" }, + { 0xf980, "\x54\x42" }, + { 0xf981, "\x59\x73" }, + { 0xf982, "\x5e\xec" }, + { 0xf983, "\x65\xc5" }, + { 0xf984, "\x6f\xfe" }, + { 0xf985, "\x79\x2a" }, + { 0xf986, "\x95\xad" }, + { 0xf987, "\x9a\x6a" }, + { 0xf988, "\x9e\x97" }, + { 0xf989, "\x9e\xce" }, + { 0xf98a, "\x52\x9b" }, + { 0xf98b, "\x66\xc6" }, + { 0xf98c, "\x6b\x77" }, + { 0xf98d, "\x8f\x62" }, + { 0xf98e, "\x5e\x74" }, + { 0xf98f, "\x61\x90" }, + { 0xf990, "\x62\x00" }, + { 0xf991, "\x64\x9a" }, + { 0xf992, "\x6f\x23" }, + { 0xf993, "\x71\x49" }, + { 0xf994, "\x74\x89" }, + { 0xf995, "\x79\xca" }, + { 0xf996, "\x7d\xf4" }, + { 0xf997, "\x80\x6f" }, + { 0xf998, "\x8f\x26" }, + { 0xf999, "\x84\xee" }, + { 0xf99a, "\x90\x23" }, + { 0xf99b, "\x93\x4a" }, + { 0xf99c, "\x52\x17" }, + { 0xf99d, "\x52\xa3" }, + { 0xf99e, "\x54\xbd" }, + { 0xf99f, "\x70\xc8" }, + { 0xf9a0, "\x88\xc2" }, + { 0xf9a1, "\x8a\xaa" }, + { 0xf9a2, "\x5e\xc9" }, + { 0xf9a3, "\x5f\xf5" }, + { 0xf9a4, "\x63\x7b" }, + { 0xf9a5, "\x6b\xae" }, + { 0xf9a6, "\x7c\x3e" }, + { 0xf9a7, "\x73\x75" }, + { 0xf9a8, "\x4e\xe4" }, + { 0xf9a9, "\x56\xf9" }, + { 0xf9aa, "\x5b\xe7" }, + { 0xf9ab, "\x5d\xba" }, + { 0xf9ac, "\x60\x1c" }, + { 0xf9ad, "\x73\xb2" }, + { 0xf9ae, "\x74\x69" }, + { 0xf9af, "\x7f\x9a" }, + { 0xf9b0, "\x80\x46" }, + { 0xf9b1, "\x92\x34" }, + { 0xf9b2, "\x96\xf6" }, + { 0xf9b3, "\x97\x48" }, + { 0xf9b4, "\x98\x18" }, + { 0xf9b5, "\x4f\x8b" }, + { 0xf9b6, "\x79\xae" }, + { 0xf9b7, "\x91\xb4" }, + { 0xf9b8, "\x96\xb8" }, + { 0xf9b9, "\x60\xe1" }, + { 0xf9ba, "\x4e\x86" }, + { 0xf9bb, "\x50\xda" }, + { 0xf9bc, "\x5b\xee" }, + { 0xf9bd, "\x5c\x3f" }, + { 0xf9be, "\x65\x99" }, + { 0xf9bf, "\x6a\x02" }, + { 0xf9c0, "\x71\xce" }, + { 0xf9c1, "\x76\x42" }, + { 0xf9c2, "\x84\xfc" }, + { 0xf9c3, "\x90\x7c" }, + { 0xf9c4, "\x9f\x8d" }, + { 0xf9c5, "\x66\x88" }, + { 0xf9c6, "\x96\x2e" }, + { 0xf9c7, "\x52\x89" }, + { 0xf9c8, "\x67\x7b" }, + { 0xf9c9, "\x67\xf3" }, + { 0xf9ca, "\x6d\x41" }, + { 0xf9cb, "\x6e\x9c" }, + { 0xf9cc, "\x74\x09" }, + { 0xf9cd, "\x75\x59" }, + { 0xf9ce, "\x78\x6b" }, + { 0xf9cf, "\x7d\x10" }, + { 0xf9d0, "\x98\x5e" }, + { 0xf9d1, "\x51\x6d" }, + { 0xf9d2, "\x62\x2e" }, + { 0xf9d3, "\x96\x78" }, + { 0xf9d4, "\x50\x2b" }, + { 0xf9d5, "\x5d\x19" }, + { 0xf9d6, "\x6d\xea" }, + { 0xf9d7, "\x8f\x2a" }, + { 0xf9d8, "\x5f\x8b" }, + { 0xf9d9, "\x61\x44" }, + { 0xf9da, "\x68\x17" }, + { 0xf9db, "\x73\x87" }, + { 0xf9dc, "\x96\x86" }, + { 0xf9dd, "\x52\x29" }, + { 0xf9de, "\x54\x0f" }, + { 0xf9df, "\x5c\x65" }, + { 0xf9e0, "\x66\x13" }, + { 0xf9e1, "\x67\x4e" }, + { 0xf9e2, "\x68\xa8" }, + { 0xf9e3, "\x6c\xe5" }, + { 0xf9e4, "\x74\x06" }, + { 0xf9e5, "\x75\xe2" }, + { 0xf9e6, "\x7f\x79" }, + { 0xf9e7, "\x88\xcf" }, + { 0xf9e8, "\x88\xe1" }, + { 0xf9e9, "\x91\xcc" }, + { 0xf9ea, "\x96\xe2" }, + { 0xf9eb, "\x53\x3f" }, + { 0xf9ec, "\x6e\xba" }, + { 0xf9ed, "\x54\x1d" }, + { 0xf9ee, "\x71\xd0" }, + { 0xf9ef, "\x74\x98" }, + { 0xf9f0, "\x85\xfa" }, + { 0xf9f1, "\x96\xa3" }, + { 0xf9f2, "\x9c\x57" }, + { 0xf9f3, "\x9e\x9f" }, + { 0xf9f4, "\x67\x97" }, + { 0xf9f5, "\x6d\xcb" }, + { 0xf9f6, "\x81\xe8" }, + { 0xf9f7, "\x7a\xcb" }, + { 0xf9f8, "\x7b\x20" }, + { 0xf9f9, "\x7c\x92" }, + { 0xf9fa, "\x72\xc0" }, + { 0xf9fb, "\x70\x99" }, + { 0xf9fc, "\x8b\x58" }, + { 0xf9fd, "\x4e\xc0" }, + { 0xf9fe, "\x83\x36" }, + { 0xf9ff, "\x52\x3a" }, + { 0xfa00, "\x52\x07" }, + { 0xfa01, "\x5e\xa6" }, + { 0xfa02, "\x62\xd3" }, + { 0xfa03, "\x7c\xd6" }, + { 0xfa04, "\x5b\x85" }, + { 0xfa05, "\x6d\x1e" }, + { 0xfa06, "\x66\xb4" }, + { 0xfa07, "\x8f\x3b" }, + { 0xfa08, "\x88\x4c" }, + { 0xfa09, "\x96\x4d" }, + { 0xfa0a, "\x89\x8b" }, + { 0xfa0b, "\x5e\xd3" }, + { 0xfa0c, "\x51\x40" }, + { 0xfa0d, "\x55\xc0" }, + { 0xfa10, "\x58\x5a" }, + { 0xfa12, "\x66\x74" }, + { 0xfa15, "\x51\xde" }, + { 0xfa16, "\x73\x2a" }, + { 0xfa17, "\x76\xca" }, + { 0xfa18, "\x79\x3c" }, + { 0xfa19, "\x79\x5e" }, + { 0xfa1a, "\x79\x65" }, + { 0xfa1b, "\x79\x8f" }, + { 0xfa1c, "\x97\x56" }, + { 0xfa1d, "\x7c\xbe" }, + { 0xfa1e, "\x7f\xbd" }, + { 0xfa20, "\x86\x12" }, + { 0xfa22, "\x8a\xf8" }, + { 0xfa25, "\x90\x38" }, + { 0xfa26, "\x90\xfd" }, + { 0xfa2a, "\x98\xef" }, + { 0xfa2b, "\x98\xfc" }, + { 0xfa2c, "\x99\x28" }, + { 0xfa2d, "\x9d\xb4" }, + { 0xfb1f, "\x05\xf2\x05\xb7" }, + { 0xfb2a, "\x05\xe9\x05\xc1" }, + { 0xfb2b, "\x05\xe9\x05\xc2" }, + { 0xfb2c, "\xfb\x49\x05\xc1" }, + { 0xfb2d, "\xfb\x49\x05\xc2" }, + { 0xfb2e, "\x05\xd0\x05\xb7" }, + { 0xfb2f, "\x05\xd0\x05\xb8" }, + { 0xfb30, "\x05\xd0\x05\xbc" }, + { 0xfb31, "\x05\xd1\x05\xbc" }, + { 0xfb32, "\x05\xd2\x05\xbc" }, + { 0xfb33, "\x05\xd3\x05\xbc" }, + { 0xfb34, "\x05\xd4\x05\xbc" }, + { 0xfb35, "\x05\xd5\x05\xbc" }, + { 0xfb36, "\x05\xd6\x05\xbc" }, + { 0xfb38, "\x05\xd8\x05\xbc" }, + { 0xfb39, "\x05\xd9\x05\xbc" }, + { 0xfb3a, "\x05\xda\x05\xbc" }, + { 0xfb3b, "\x05\xdb\x05\xbc" }, + { 0xfb3c, "\x05\xdc\x05\xbc" }, + { 0xfb3e, "\x05\xde\x05\xbc" }, + { 0xfb40, "\x05\xe0\x05\xbc" }, + { 0xfb41, "\x05\xe1\x05\xbc" }, + { 0xfb43, "\x05\xe3\x05\xbc" }, + { 0xfb44, "\x05\xe4\x05\xbc" }, + { 0xfb46, "\x05\xe6\x05\xbc" }, + { 0xfb47, "\x05\xe7\x05\xbc" }, + { 0xfb48, "\x05\xe8\x05\xbc" }, + { 0xfb49, "\x05\xe9\x05\xbc" }, + { 0xfb4a, "\x05\xea\x05\xbc" }, + { 0xfb4b, "\x05\xd5\x05\xb9" }, + { 0xfb4c, "\x05\xd1\x05\xbf" }, + { 0xfb4d, "\x05\xdb\x05\xbf" }, + { 0xfb4e, "\x05\xe4\x05\xbf" } +}; + +static const decomp_entry full_decomposition[] = +{ + { 0x005e, "\x00\x20\x03\x02" }, + { 0x005f, "\x00\x20\x03\x32" }, + { 0x0060, "\x00\x20\x03\x00" }, + { 0x00a0, "\x00\x20" }, + { 0x00a8, "\x00\x20\x03\x08" }, + { 0x00aa, "\x00\x61" }, + { 0x00af, "\x00\x20\x03\x04" }, + { 0x00b2, "\x00\x32" }, + { 0x00b3, "\x00\x33" }, + { 0x00b4, "\x00\x20\x03\x01" }, + { 0x00b5, "\x03\xbc" }, + { 0x00b8, "\x00\x20\x03\x27" }, + { 0x00b9, "\x00\x31" }, + { 0x00ba, "\x00\x6f" }, + { 0x00bc, "\x00\x31\x20\x44\x00\x34" }, + { 0x00bd, "\x00\x31\x20\x44\x00\x32" }, + { 0x00be, "\x00\x33\x20\x44\x00\x34" }, + { 0x0132, "\x00\x49\x00\x4a" }, + { 0x0133, "\x00\x69\x00\x6a" }, + { 0x013f, "\x00\x4c\x00\xb7" }, + { 0x0140, "\x00\x6c\x00\xb7" }, + { 0x0149, "\x02\xbc\x00\x6e" }, + { 0x017f, "\x00\x73" }, + { 0x01c4, "\x00\x44\x01\x7d" }, + { 0x01c5, "\x00\x44\x01\x7e" }, + { 0x01c6, "\x00\x64\x01\x7e" }, + { 0x01c7, "\x00\x4c\x00\x4a" }, + { 0x01c8, "\x00\x4c\x00\x6a" }, + { 0x01c9, "\x00\x6c\x00\x6a" }, + { 0x01ca, "\x00\x4e\x00\x4a" }, + { 0x01cb, "\x00\x4e\x00\x6a" }, + { 0x01cc, "\x00\x6e\x00\x6a" }, + { 0x01f1, "\x00\x44\x00\x5a" }, + { 0x01f2, "\x00\x44\x00\x7a" }, + { 0x01f3, "\x00\x64\x00\x7a" }, + { 0x02b0, "\x00\x68" }, + { 0x02b1, "\x02\x66" }, + { 0x02b2, "\x00\x6a" }, + { 0x02b3, "\x00\x72" }, + { 0x02b4, "\x02\x79" }, + { 0x02b5, "\x02\x7b" }, + { 0x02b6, "\x02\x81" }, + { 0x02b7, "\x00\x77" }, + { 0x02b8, "\x00\x79" }, + { 0x02d8, "\x00\x20\x03\x06" }, + { 0x02d9, "\x00\x20\x03\x07" }, + { 0x02da, "\x00\x20\x03\x0a" }, + { 0x02db, "\x00\x20\x03\x28" }, + { 0x02dc, "\x00\x20\x03\x03" }, + { 0x02dd, "\x00\x20\x03\x0b" }, + { 0x02e0, "\x02\x63" }, + { 0x02e1, "\x00\x6c" }, + { 0x02e2, "\x00\x73" }, + { 0x02e3, "\x00\x78" }, + { 0x02e4, "\x02\x95" }, + { 0x037a, "\x00\x20\x03\x45" }, + { 0x0384, "\x00\x20\x03\x01" }, + { 0x0587, "\x05\x65\x05\x82" }, + { 0x0edc, "\x0e\xab\x0e\x99" }, + { 0x0edd, "\x0e\xab\x0e\xa1" }, + { 0x1101, "\x11\x00\x11\x00" }, + { 0x1104, "\x11\x03\x11\x03" }, + { 0x1108, "\x11\x07\x11\x07" }, + { 0x110a, "\x11\x09\x11\x09" }, + { 0x110d, "\x11\x0c\x11\x0c" }, + { 0x1113, "\x11\x02\x11\x00" }, + { 0x1114, "\x11\x02\x11\x02" }, + { 0x1115, "\x11\x02\x11\x03" }, + { 0x1116, "\x11\x02\x11\x07" }, + { 0x1117, "\x11\x03\x11\x00" }, + { 0x1118, "\x11\x05\x11\x02" }, + { 0x1119, "\x11\x05\x11\x05" }, + { 0x111a, "\x11\x05\x11\x12" }, + { 0x111b, "\x11\x05\x11\x0b" }, + { 0x111c, "\x11\x06\x11\x07" }, + { 0x111d, "\x11\x06\x11\x0b" }, + { 0x111e, "\x11\x07\x11\x00" }, + { 0x111f, "\x11\x07\x11\x02" }, + { 0x1120, "\x11\x07\x11\x03" }, + { 0x1121, "\x11\x07\x11\x09" }, + { 0x1122, "\x11\x07\x11\x09\x11\x00" }, + { 0x1123, "\x11\x07\x11\x09\x11\x03" }, + { 0x1124, "\x11\x07\x11\x09\x11\x07" }, + { 0x1125, "\x11\x07\x11\x09\x11\x09" }, + { 0x1126, "\x11\x07\x11\x09\x11\x0c" }, + { 0x1127, "\x11\x07\x11\x0c" }, + { 0x1128, "\x11\x07\x11\x0e" }, + { 0x1129, "\x11\x07\x11\x10" }, + { 0x112a, "\x11\x07\x11\x11" }, + { 0x112b, "\x11\x07\x11\x0b" }, + { 0x112c, "\x11\x07\x11\x07\x11\x0b" }, + { 0x112d, "\x11\x09\x11\x00" }, + { 0x112e, "\x11\x09\x11\x02" }, + { 0x112f, "\x11\x09\x11\x03" }, + { 0x1130, "\x11\x09\x11\x05" }, + { 0x1131, "\x11\x09\x11\x06" }, + { 0x1132, "\x11\x09\x11\x07" }, + { 0x1133, "\x11\x09\x11\x07\x11\x00" }, + { 0x1134, "\x11\x09\x11\x09\x11\x09" }, + { 0x1135, "\x11\x09\x11\x0b" }, + { 0x1136, "\x11\x09\x11\x0c" }, + { 0x1137, "\x11\x09\x11\x0e" }, + { 0x1138, "\x11\x09\x11\x0f" }, + { 0x1139, "\x11\x09\x11\x10" }, + { 0x113a, "\x11\x09\x11\x11" }, + { 0x113b, "\x11\x09\x11\x12" }, + { 0x113d, "\x11\x3c\x11\x3c" }, + { 0x113f, "\x11\x3e\x11\x3e" }, + { 0x1141, "\x11\x0b\x11\x00" }, + { 0x1142, "\x11\x0b\x11\x03" }, + { 0x1143, "\x11\x0b\x11\x06" }, + { 0x1144, "\x11\x0b\x11\x07" }, + { 0x1145, "\x11\x0b\x11\x09" }, + { 0x1146, "\x11\x0b\x11\x40" }, + { 0x1147, "\x11\x0b\x11\x0b" }, + { 0x1148, "\x11\x0b\x11\x0c" }, + { 0x1149, "\x11\x0b\x11\x0e" }, + { 0x114a, "\x11\x0b\x11\x10" }, + { 0x114b, "\x11\x0b\x11\x11" }, + { 0x114d, "\x11\x0c\x11\x0b" }, + { 0x114f, "\x11\x4e\x11\x4e" }, + { 0x1151, "\x11\x50\x11\x50" }, + { 0x1152, "\x11\x0e\x11\x0f" }, + { 0x1153, "\x11\x0e\x11\x12" }, + { 0x1156, "\x11\x11\x11\x07" }, + { 0x1157, "\x11\x11\x11\x0b" }, + { 0x1158, "\x11\x12\x11\x12" }, + { 0x1162, "\x11\x61\x11\x75" }, + { 0x1164, "\x11\x63\x11\x75" }, + { 0x1166, "\x11\x65\x11\x75" }, + { 0x1168, "\x11\x67\x11\x75" }, + { 0x116a, "\x11\x69\x11\x61" }, + { 0x116b, "\x11\x69\x11\x61\x11\x75" }, + { 0x116c, "\x11\x69\x11\x75" }, + { 0x116f, "\x11\x6e\x11\x65" }, + { 0x1170, "\x11\x6e\x11\x65\x11\x75" }, + { 0x1171, "\x11\x6e\x11\x75" }, + { 0x1174, "\x11\x73\x11\x75" }, + { 0x1176, "\x11\x61\x11\x69" }, + { 0x1177, "\x11\x61\x11\x6e" }, + { 0x1178, "\x11\x63\x11\x69" }, + { 0x1179, "\x11\x63\x11\x6d" }, + { 0x117a, "\x11\x65\x11\x69" }, + { 0x117b, "\x11\x65\x11\x6e" }, + { 0x117c, "\x11\x65\x11\x73" }, + { 0x117d, "\x11\x67\x11\x69" }, + { 0x117e, "\x11\x67\x11\x6e" }, + { 0x117f, "\x11\x69\x11\x65" }, + { 0x1180, "\x11\x69\x11\x66" }, + { 0x1181, "\x11\x69\x11\x68" }, + { 0x1182, "\x11\x69\x11\x69" }, + { 0x1183, "\x11\x69\x11\x6e" }, + { 0x1184, "\x11\x6d\x11\x63" }, + { 0x1185, "\x11\x6d\x11\x64" }, + { 0x1186, "\x11\x6d\x11\x67" }, + { 0x1187, "\x11\x6d\x11\x69" }, + { 0x1188, "\x11\x6d\x11\x75" }, + { 0x1189, "\x11\x6e\x11\x61" }, + { 0x118a, "\x11\x6e\x11\x62" }, + { 0x118b, "\x11\x6e\x11\x65\x11\x73" }, + { 0x118c, "\x11\x6e\x11\x68" }, + { 0x118d, "\x11\x6e\x11\x6e" }, + { 0x118e, "\x11\x72\x11\x61" }, + { 0x118f, "\x11\x72\x11\x65" }, + { 0x1190, "\x11\x72\x11\x66" }, + { 0x1191, "\x11\x72\x11\x67" }, + { 0x1192, "\x11\x72\x11\x68" }, + { 0x1193, "\x11\x72\x11\x6e" }, + { 0x1194, "\x11\x72\x11\x75" }, + { 0x1195, "\x11\x73\x11\x6e" }, + { 0x1196, "\x11\x73\x11\x73" }, + { 0x1197, "\x11\x74\x11\x6e" }, + { 0x1198, "\x11\x75\x11\x61" }, + { 0x1199, "\x11\x75\x11\x63" }, + { 0x119a, "\x11\x75\x11\x69" }, + { 0x119b, "\x11\x75\x11\x6e" }, + { 0x119c, "\x11\x75\x11\x73" }, + { 0x119d, "\x11\x75\x11\x9e" }, + { 0x119f, "\x11\x9e\x11\x65" }, + { 0x11a0, "\x11\x9e\x11\x6e" }, + { 0x11a1, "\x11\x9e\x11\x75" }, + { 0x11a2, "\x11\x9e\x11\x9e" }, + { 0x11a9, "\x11\xa8\x11\xa8" }, + { 0x11aa, "\x11\xa8\x11\xba" }, + { 0x11ac, "\x11\xab\x11\xbd" }, + { 0x11ad, "\x11\xab\x11\xc2" }, + { 0x11b0, "\x11\xaf\x11\xa8" }, + { 0x11b1, "\x11\xaf\x11\xb7" }, + { 0x11b2, "\x11\xaf\x11\xb8" }, + { 0x11b3, "\x11\xaf\x11\xba" }, + { 0x11b4, "\x11\xaf\x11\xc0" }, + { 0x11b5, "\x11\xaf\x11\xc1" }, + { 0x11b6, "\x11\xaf\x11\xc2" }, + { 0x11b9, "\x11\xb8\x11\xba" }, + { 0x11bb, "\x11\xba\x11\xba" }, + { 0x11c3, "\x11\xa8\x11\xaf" }, + { 0x11c4, "\x11\xa8\x11\xba\x11\xa8" }, + { 0x11c5, "\x11\xab\x11\xa8" }, + { 0x11c6, "\x11\xab\x11\xae" }, + { 0x11c7, "\x11\xab\x11\xba" }, + { 0x11c8, "\x11\xab\x11\xeb" }, + { 0x11c9, "\x11\xab\x11\xc0" }, + { 0x11ca, "\x11\xae\x11\xa8" }, + { 0x11cb, "\x11\xae\x11\xaf" }, + { 0x11cc, "\x11\xaf\x11\xa8\x11\xba" }, + { 0x11cd, "\x11\xaf\x11\xab" }, + { 0x11ce, "\x11\xaf\x11\xae" }, + { 0x11cf, "\x11\xaf\x11\xae\x11\xc2" }, + { 0x11d0, "\x11\xaf\x11\xaf" }, + { 0x11d1, "\x11\xaf\x11\xb7\x11\xa8" }, + { 0x11d2, "\x11\xaf\x11\xb7\x11\xba" }, + { 0x11d3, "\x11\xaf\x11\xb8\x11\xba" }, + { 0x11d4, "\x11\xaf\x11\xb8\x11\xc2" }, + { 0x11d5, "\x11\xaf\x11\xb8\x11\xbc" }, + { 0x11d6, "\x11\xaf\x11\xba\x11\xba" }, + { 0x11d7, "\x11\xaf\x11\xeb" }, + { 0x11d8, "\x11\xaf\x11\xbf" }, + { 0x11d9, "\x11\xaf\x11\xf9" }, + { 0x11da, "\x11\xb7\x11\xa8" }, + { 0x11db, "\x11\xb7\x11\xaf" }, + { 0x11dc, "\x11\xb7\x11\xb8" }, + { 0x11dd, "\x11\xb7\x11\xba" }, + { 0x11de, "\x11\xb7\x11\xba\x11\xba" }, + { 0x11df, "\x11\xb7\x11\xeb" }, + { 0x11e0, "\x11\xb7\x11\xbe" }, + { 0x11e1, "\x11\xb7\x11\xc2" }, + { 0x11e2, "\x11\xb7\x11\xbc" }, + { 0x11e3, "\x11\xb8\x11\xaf" }, + { 0x11e4, "\x11\xb8\x11\xc1" }, + { 0x11e5, "\x11\xb8\x11\xc2" }, + { 0x11e6, "\x11\xb8\x11\xbc" }, + { 0x11e7, "\x11\xba\x11\xa8" }, + { 0x11e8, "\x11\xba\x11\xae" }, + { 0x11e9, "\x11\xba\x11\xaf" }, + { 0x11ea, "\x11\xba\x11\xb8" }, + { 0x11ec, "\x11\xbc\x11\xa8" }, + { 0x11ed, "\x11\xbc\x11\xa8\x11\xa8" }, + { 0x11ee, "\x11\xbc\x11\xbc" }, + { 0x11ef, "\x11\xbc\x11\xbf" }, + { 0x11f1, "\x11\xf0\x11\xba" }, + { 0x11f2, "\x11\xf0\x11\xeb" }, + { 0x11f3, "\x11\xc1\x11\xb8" }, + { 0x11f4, "\x11\xc1\x11\xbc" }, + { 0x11f5, "\x11\xc2\x11\xab" }, + { 0x11f6, "\x11\xc2\x11\xaf" }, + { 0x11f7, "\x11\xc2\x11\xb7" }, + { 0x11f8, "\x11\xc2\x11\xb8" }, + { 0x1e9a, "\x00\x61\x02\xbe" }, + { 0x1fbd, "\x00\x20\x03\x13" }, + { 0x1fbf, "\x00\x20\x03\x13" }, + { 0x1fc0, "\x00\x20\x03\x42" }, + { 0x1ffe, "\x00\x20\x03\x14" }, + { 0x2002, "\x00\x20" }, + { 0x2003, "\x00\x20" }, + { 0x2004, "\x00\x20" }, + { 0x2005, "\x00\x20" }, + { 0x2006, "\x00\x20" }, + { 0x2007, "\x00\x20" }, + { 0x2008, "\x00\x20" }, + { 0x2009, "\x00\x20" }, + { 0x200a, "\x00\x20" }, + { 0x2011, "\x20\x10" }, + { 0x2017, "\x00\x20\x03\x33" }, + { 0x2024, "\x00\x2e" }, + { 0x2025, "\x00\x2e\x00\x2e" }, + { 0x2026, "\x00\x2e\x00\x2e\x00\x2e" }, + { 0x2033, "\x20\x32\x20\x32" }, + { 0x2034, "\x20\x32\x20\x32\x20\x32" }, + { 0x2036, "\x20\x35\x20\x35" }, + { 0x2037, "\x20\x35\x20\x35\x20\x35" }, + { 0x203c, "\x00\x21\x00\x21" }, + { 0x203e, "\x00\x20\x03\x05" }, + { 0x2070, "\x00\x30" }, + { 0x2074, "\x00\x34" }, + { 0x2075, "\x00\x35" }, + { 0x2076, "\x00\x36" }, + { 0x2077, "\x00\x37" }, + { 0x2078, "\x00\x38" }, + { 0x2079, "\x00\x39" }, + { 0x207a, "\x00\x2b" }, + { 0x207b, "\x22\x12" }, + { 0x207c, "\x00\x3d" }, + { 0x207d, "\x00\x28" }, + { 0x207e, "\x00\x29" }, + { 0x207f, "\x00\x6e" }, + { 0x2080, "\x00\x30" }, + { 0x2081, "\x00\x31" }, + { 0x2082, "\x00\x32" }, + { 0x2083, "\x00\x33" }, + { 0x2084, "\x00\x34" }, + { 0x2085, "\x00\x35" }, + { 0x2086, "\x00\x36" }, + { 0x2087, "\x00\x37" }, + { 0x2088, "\x00\x38" }, + { 0x2089, "\x00\x39" }, + { 0x208a, "\x00\x2b" }, + { 0x208b, "\x22\x12" }, + { 0x208c, "\x00\x3d" }, + { 0x208d, "\x00\x28" }, + { 0x208e, "\x00\x29" }, + { 0x20a8, "\x00\x52\x00\x73" }, + { 0x2100, "\x00\x61\x00\x2f\x00\x63" }, + { 0x2101, "\x00\x61\x00\x2f\x00\x73" }, + { 0x2102, "\x00\x43" }, + { 0x2103, "\x00\xb0\x00\x43" }, + { 0x2105, "\x00\x63\x00\x2f\x00\x6f" }, + { 0x2106, "\x00\x63\x00\x2f\x00\x75" }, + { 0x2107, "\x01\x90" }, + { 0x2109, "\x00\xb0\x00\x46" }, + { 0x210a, "\x00\x67" }, + { 0x210b, "\x00\x48" }, + { 0x210c, "\x00\x48" }, + { 0x210d, "\x00\x48" }, + { 0x210e, "\x00\x68" }, + { 0x210f, "\x01\x27" }, + { 0x2110, "\x00\x49" }, + { 0x2111, "\x00\x49" }, + { 0x2112, "\x00\x4c" }, + { 0x2113, "\x00\x6c" }, + { 0x2115, "\x00\x4e" }, + { 0x2116, "\x00\x4e\x00\x6f" }, + { 0x2119, "\x00\x50" }, + { 0x211a, "\x00\x51" }, + { 0x211b, "\x00\x52" }, + { 0x211c, "\x00\x52" }, + { 0x211d, "\x00\x52" }, + { 0x2120, "\x00\x53\x00\x4d" }, + { 0x2121, "\x00\x54\x00\x45\x00\x4c" }, + { 0x2122, "\x00\x54\x00\x4d" }, + { 0x2124, "\x00\x5a" }, + { 0x2128, "\x00\x5a" }, + { 0x212c, "\x00\x42" }, + { 0x212d, "\x00\x43" }, + { 0x212f, "\x00\x65" }, + { 0x2130, "\x00\x45" }, + { 0x2131, "\x00\x46" }, + { 0x2133, "\x00\x4d" }, + { 0x2134, "\x00\x6f" }, + { 0x2135, "\x05\xd0" }, + { 0x2136, "\x05\xd1" }, + { 0x2137, "\x05\xd2" }, + { 0x2138, "\x05\xd3" }, + { 0x2153, "\x00\x31\x20\x44\x00\x33" }, + { 0x2154, "\x00\x32\x20\x44\x00\x33" }, + { 0x2155, "\x00\x31\x20\x44\x00\x35" }, + { 0x2156, "\x00\x32\x20\x44\x00\x35" }, + { 0x2157, "\x00\x33\x20\x44\x00\x35" }, + { 0x2158, "\x00\x34\x20\x44\x00\x35" }, + { 0x2159, "\x00\x31\x20\x44\x00\x36" }, + { 0x215a, "\x00\x35\x20\x44\x00\x36" }, + { 0x215b, "\x00\x31\x20\x44\x00\x38" }, + { 0x215c, "\x00\x33\x20\x44\x00\x38" }, + { 0x215d, "\x00\x35\x20\x44\x00\x38" }, + { 0x215e, "\x00\x37\x20\x44\x00\x38" }, + { 0x215f, "\x00\x31\x20\x44" }, + { 0x2160, "\x00\x49" }, + { 0x2161, "\x00\x49\x00\x49" }, + { 0x2162, "\x00\x49\x00\x49\x00\x49" }, + { 0x2163, "\x00\x49\x00\x56" }, + { 0x2164, "\x00\x56" }, + { 0x2165, "\x00\x56\x00\x49" }, + { 0x2166, "\x00\x56\x00\x49\x00\x49" }, + { 0x2167, "\x00\x56\x00\x49\x00\x49\x00\x49" }, + { 0x2168, "\x00\x49\x00\x58" }, + { 0x2169, "\x00\x58" }, + { 0x216a, "\x00\x58\x00\x49" }, + { 0x216b, "\x00\x58\x00\x49\x00\x49" }, + { 0x216c, "\x00\x4c" }, + { 0x216d, "\x00\x43" }, + { 0x216e, "\x00\x44" }, + { 0x216f, "\x00\x4d" }, + { 0x2170, "\x00\x69" }, + { 0x2171, "\x00\x69\x00\x69" }, + { 0x2172, "\x00\x69\x00\x69\x00\x69" }, + { 0x2173, "\x00\x69\x00\x76" }, + { 0x2174, "\x00\x76" }, + { 0x2175, "\x00\x76\x00\x69" }, + { 0x2176, "\x00\x76\x00\x69\x00\x69" }, + { 0x2177, "\x00\x76\x00\x69\x00\x69\x00\x69" }, + { 0x2178, "\x00\x69\x00\x78" }, + { 0x2179, "\x00\x78" }, + { 0x217a, "\x00\x78\x00\x69" }, + { 0x217b, "\x00\x78\x00\x69\x00\x69" }, + { 0x217c, "\x00\x6c" }, + { 0x217d, "\x00\x63" }, + { 0x217e, "\x00\x64" }, + { 0x217f, "\x00\x6d" }, + { 0x222c, "\x22\x2b\x22\x2b" }, + { 0x222d, "\x22\x2b\x22\x2b\x22\x2b" }, + { 0x222f, "\x22\x2e\x22\x2e" }, + { 0x2230, "\x22\x2e\x22\x2e\x22\x2e" }, + { 0x2460, "\x00\x31" }, + { 0x2461, "\x00\x32" }, + { 0x2462, "\x00\x33" }, + { 0x2463, "\x00\x34" }, + { 0x2464, "\x00\x35" }, + { 0x2465, "\x00\x36" }, + { 0x2466, "\x00\x37" }, + { 0x2467, "\x00\x38" }, + { 0x2468, "\x00\x39" }, + { 0x2469, "\x00\x31\x00\x30" }, + { 0x246a, "\x00\x31\x00\x31" }, + { 0x246b, "\x00\x31\x00\x32" }, + { 0x246c, "\x00\x31\x00\x33" }, + { 0x246d, "\x00\x31\x00\x34" }, + { 0x246e, "\x00\x31\x00\x35" }, + { 0x246f, "\x00\x31\x00\x36" }, + { 0x2470, "\x00\x31\x00\x37" }, + { 0x2471, "\x00\x31\x00\x38" }, + { 0x2472, "\x00\x31\x00\x39" }, + { 0x2473, "\x00\x32\x00\x30" }, + { 0x2474, "\x00\x28\x00\x31\x00\x29" }, + { 0x2475, "\x00\x28\x00\x32\x00\x29" }, + { 0x2476, "\x00\x28\x00\x33\x00\x29" }, + { 0x2477, "\x00\x28\x00\x34\x00\x29" }, + { 0x2478, "\x00\x28\x00\x35\x00\x29" }, + { 0x2479, "\x00\x28\x00\x36\x00\x29" }, + { 0x247a, "\x00\x28\x00\x37\x00\x29" }, + { 0x247b, "\x00\x28\x00\x38\x00\x29" }, + { 0x247c, "\x00\x28\x00\x39\x00\x29" }, + { 0x247d, "\x00\x28\x00\x31\x00\x30\x00\x29" }, + { 0x247e, "\x00\x28\x00\x31\x00\x31\x00\x29" }, + { 0x247f, "\x00\x28\x00\x31\x00\x32\x00\x29" }, + { 0x2480, "\x00\x28\x00\x31\x00\x33\x00\x29" }, + { 0x2481, "\x00\x28\x00\x31\x00\x34\x00\x29" }, + { 0x2482, "\x00\x28\x00\x31\x00\x35\x00\x29" }, + { 0x2483, "\x00\x28\x00\x31\x00\x36\x00\x29" }, + { 0x2484, "\x00\x28\x00\x31\x00\x37\x00\x29" }, + { 0x2485, "\x00\x28\x00\x31\x00\x38\x00\x29" }, + { 0x2486, "\x00\x28\x00\x31\x00\x39\x00\x29" }, + { 0x2487, "\x00\x28\x00\x32\x00\x30\x00\x29" }, + { 0x2488, "\x00\x31\x00\x2e" }, + { 0x2489, "\x00\x32\x00\x2e" }, + { 0x248a, "\x00\x33\x00\x2e" }, + { 0x248b, "\x00\x34\x00\x2e" }, + { 0x248c, "\x00\x35\x00\x2e" }, + { 0x248d, "\x00\x36\x00\x2e" }, + { 0x248e, "\x00\x37\x00\x2e" }, + { 0x248f, "\x00\x38\x00\x2e" }, + { 0x2490, "\x00\x39\x00\x2e" }, + { 0x2491, "\x00\x31\x00\x30\x00\x2e" }, + { 0x2492, "\x00\x31\x00\x31\x00\x2e" }, + { 0x2493, "\x00\x31\x00\x32\x00\x2e" }, + { 0x2494, "\x00\x31\x00\x33\x00\x2e" }, + { 0x2495, "\x00\x31\x00\x34\x00\x2e" }, + { 0x2496, "\x00\x31\x00\x35\x00\x2e" }, + { 0x2497, "\x00\x31\x00\x36\x00\x2e" }, + { 0x2498, "\x00\x31\x00\x37\x00\x2e" }, + { 0x2499, "\x00\x31\x00\x38\x00\x2e" }, + { 0x249a, "\x00\x31\x00\x39\x00\x2e" }, + { 0x249b, "\x00\x32\x00\x30\x00\x2e" }, + { 0x249c, "\x00\x28\x00\x61\x00\x29" }, + { 0x249d, "\x00\x28\x00\x62\x00\x29" }, + { 0x249e, "\x00\x28\x00\x63\x00\x29" }, + { 0x249f, "\x00\x28\x00\x64\x00\x29" }, + { 0x24a0, "\x00\x28\x00\x65\x00\x29" }, + { 0x24a1, "\x00\x28\x00\x66\x00\x29" }, + { 0x24a2, "\x00\x28\x00\x67\x00\x29" }, + { 0x24a3, "\x00\x28\x00\x68\x00\x29" }, + { 0x24a4, "\x00\x28\x00\x69\x00\x29" }, + { 0x24a5, "\x00\x28\x00\x6a\x00\x29" }, + { 0x24a6, "\x00\x28\x00\x6b\x00\x29" }, + { 0x24a7, "\x00\x28\x00\x6c\x00\x29" }, + { 0x24a8, "\x00\x28\x00\x6d\x00\x29" }, + { 0x24a9, "\x00\x28\x00\x6e\x00\x29" }, + { 0x24aa, "\x00\x28\x00\x6f\x00\x29" }, + { 0x24ab, "\x00\x28\x00\x70\x00\x29" }, + { 0x24ac, "\x00\x28\x00\x71\x00\x29" }, + { 0x24ad, "\x00\x28\x00\x72\x00\x29" }, + { 0x24ae, "\x00\x28\x00\x73\x00\x29" }, + { 0x24af, "\x00\x28\x00\x74\x00\x29" }, + { 0x24b0, "\x00\x28\x00\x75\x00\x29" }, + { 0x24b1, "\x00\x28\x00\x76\x00\x29" }, + { 0x24b2, "\x00\x28\x00\x77\x00\x29" }, + { 0x24b3, "\x00\x28\x00\x78\x00\x29" }, + { 0x24b4, "\x00\x28\x00\x79\x00\x29" }, + { 0x24b5, "\x00\x28\x00\x7a\x00\x29" }, + { 0x24b6, "\x00\x41" }, + { 0x24b7, "\x00\x42" }, + { 0x24b8, "\x00\x43" }, + { 0x24b9, "\x00\x44" }, + { 0x24ba, "\x00\x45" }, + { 0x24bb, "\x00\x46" }, + { 0x24bc, "\x00\x47" }, + { 0x24bd, "\x00\x48" }, + { 0x24be, "\x00\x49" }, + { 0x24bf, "\x00\x4a" }, + { 0x24c0, "\x00\x4b" }, + { 0x24c1, "\x00\x4c" }, + { 0x24c2, "\x00\x4d" }, + { 0x24c3, "\x00\x4e" }, + { 0x24c4, "\x00\x4f" }, + { 0x24c5, "\x00\x50" }, + { 0x24c6, "\x00\x51" }, + { 0x24c7, "\x00\x52" }, + { 0x24c8, "\x00\x53" }, + { 0x24c9, "\x00\x54" }, + { 0x24ca, "\x00\x55" }, + { 0x24cb, "\x00\x56" }, + { 0x24cc, "\x00\x57" }, + { 0x24cd, "\x00\x58" }, + { 0x24ce, "\x00\x59" }, + { 0x24cf, "\x00\x5a" }, + { 0x24d0, "\x00\x61" }, + { 0x24d1, "\x00\x62" }, + { 0x24d2, "\x00\x63" }, + { 0x24d3, "\x00\x64" }, + { 0x24d4, "\x00\x65" }, + { 0x24d5, "\x00\x66" }, + { 0x24d6, "\x00\x67" }, + { 0x24d7, "\x00\x68" }, + { 0x24d8, "\x00\x69" }, + { 0x24d9, "\x00\x6a" }, + { 0x24da, "\x00\x6b" }, + { 0x24db, "\x00\x6c" }, + { 0x24dc, "\x00\x6d" }, + { 0x24dd, "\x00\x6e" }, + { 0x24de, "\x00\x6f" }, + { 0x24df, "\x00\x70" }, + { 0x24e0, "\x00\x71" }, + { 0x24e1, "\x00\x72" }, + { 0x24e2, "\x00\x73" }, + { 0x24e3, "\x00\x74" }, + { 0x24e4, "\x00\x75" }, + { 0x24e5, "\x00\x76" }, + { 0x24e6, "\x00\x77" }, + { 0x24e7, "\x00\x78" }, + { 0x24e8, "\x00\x79" }, + { 0x24e9, "\x00\x7a" }, + { 0x24ea, "\x00\x30" }, + { 0x3000, "\x00\x20" }, + { 0x3036, "\x30\x12" }, + { 0x309b, "\x00\x20\x30\x99" }, + { 0x309c, "\x00\x20\x30\x9a" }, + { 0x3131, "\x11\x00" }, + { 0x3132, "\x11\x01" }, + { 0x3133, "\x11\xaa" }, + { 0x3134, "\x11\x02" }, + { 0x3135, "\x11\xac" }, + { 0x3136, "\x11\xad" }, + { 0x3137, "\x11\x03" }, + { 0x3138, "\x11\x04" }, + { 0x3139, "\x11\x05" }, + { 0x313a, "\x11\xb0" }, + { 0x313b, "\x11\xb1" }, + { 0x313c, "\x11\xb2" }, + { 0x313d, "\x11\xb3" }, + { 0x313e, "\x11\xb4" }, + { 0x313f, "\x11\xb5" }, + { 0x3140, "\x11\x1a" }, + { 0x3141, "\x11\x06" }, + { 0x3142, "\x11\x07" }, + { 0x3143, "\x11\x08" }, + { 0x3144, "\x11\x21" }, + { 0x3145, "\x11\x09" }, + { 0x3146, "\x11\x0a" }, + { 0x3147, "\x11\x0b" }, + { 0x3148, "\x11\x0c" }, + { 0x3149, "\x11\x0d" }, + { 0x314a, "\x11\x0e" }, + { 0x314b, "\x11\x0f" }, + { 0x314c, "\x11\x10" }, + { 0x314d, "\x11\x11" }, + { 0x314e, "\x11\x12" }, + { 0x314f, "\x11\x61" }, + { 0x3150, "\x11\x62" }, + { 0x3151, "\x11\x63" }, + { 0x3152, "\x11\x64" }, + { 0x3153, "\x11\x65" }, + { 0x3154, "\x11\x66" }, + { 0x3155, "\x11\x67" }, + { 0x3156, "\x11\x68" }, + { 0x3157, "\x11\x69" }, + { 0x3158, "\x11\x6a" }, + { 0x3159, "\x11\x6b" }, + { 0x315a, "\x11\x6c" }, + { 0x315b, "\x11\x6d" }, + { 0x315c, "\x11\x6e" }, + { 0x315d, "\x11\x6f" }, + { 0x315e, "\x11\x70" }, + { 0x315f, "\x11\x71" }, + { 0x3160, "\x11\x72" }, + { 0x3161, "\x11\x73" }, + { 0x3162, "\x11\x74" }, + { 0x3163, "\x11\x75" }, + { 0x3164, "\x11\x60" }, + { 0x3165, "\x11\x14" }, + { 0x3166, "\x11\x15" }, + { 0x3167, "\x11\xc7" }, + { 0x3168, "\x11\xc8" }, + { 0x3169, "\x11\xcc" }, + { 0x316a, "\x11\xce" }, + { 0x316b, "\x11\xd3" }, + { 0x316c, "\x11\xd7" }, + { 0x316d, "\x11\xd9" }, + { 0x316e, "\x11\x1c" }, + { 0x316f, "\x11\xdd" }, + { 0x3170, "\x11\xdf" }, + { 0x3171, "\x11\x1d" }, + { 0x3172, "\x11\x1e" }, + { 0x3173, "\x11\x20" }, + { 0x3174, "\x11\x22" }, + { 0x3175, "\x11\x23" }, + { 0x3176, "\x11\x27" }, + { 0x3177, "\x11\x29" }, + { 0x3178, "\x11\x2b" }, + { 0x3179, "\x11\x2c" }, + { 0x317a, "\x11\x2d" }, + { 0x317b, "\x11\x2e" }, + { 0x317c, "\x11\x2f" }, + { 0x317d, "\x11\x32" }, + { 0x317e, "\x11\x36" }, + { 0x317f, "\x11\x40" }, + { 0x3180, "\x11\x47" }, + { 0x3181, "\x11\x4c" }, + { 0x3182, "\x11\xf1" }, + { 0x3183, "\x11\xf2" }, + { 0x3184, "\x11\x57" }, + { 0x3185, "\x11\x58" }, + { 0x3186, "\x11\x59" }, + { 0x3187, "\x11\x84" }, + { 0x3188, "\x11\x85" }, + { 0x3189, "\x11\x88" }, + { 0x318a, "\x11\x91" }, + { 0x318b, "\x11\x92" }, + { 0x318c, "\x11\x94" }, + { 0x318d, "\x11\x9e" }, + { 0x318e, "\x11\xa1" }, + { 0x3192, "\x4e\x00" }, + { 0x3193, "\x4e\x8c" }, + { 0x3194, "\x4e\x09" }, + { 0x3195, "\x56\xdb" }, + { 0x3196, "\x4e\x0a" }, + { 0x3197, "\x4e\x2d" }, + { 0x3198, "\x4e\x0b" }, + { 0x3199, "\x75\x32" }, + { 0x319a, "\x4e\x59" }, + { 0x319b, "\x4e\x19" }, + { 0x319c, "\x4e\x01" }, + { 0x319d, "\x59\x29" }, + { 0x319e, "\x57\x30" }, + { 0x319f, "\x4e\xba" }, + { 0x3200, "\x00\x28\x11\x00\x00\x29" }, + { 0x3201, "\x00\x28\x11\x02\x00\x29" }, + { 0x3202, "\x00\x28\x11\x03\x00\x29" }, + { 0x3203, "\x00\x28\x11\x05\x00\x29" }, + { 0x3204, "\x00\x28\x11\x06\x00\x29" }, + { 0x3205, "\x00\x28\x11\x07\x00\x29" }, + { 0x3206, "\x00\x28\x11\x09\x00\x29" }, + { 0x3207, "\x00\x28\x11\x0b\x00\x29" }, + { 0x3208, "\x00\x28\x11\x0c\x00\x29" }, + { 0x3209, "\x00\x28\x11\x0e\x00\x29" }, + { 0x320a, "\x00\x28\x11\x0f\x00\x29" }, + { 0x320b, "\x00\x28\x11\x10\x00\x29" }, + { 0x320c, "\x00\x28\x11\x11\x00\x29" }, + { 0x320d, "\x00\x28\x11\x12\x00\x29" }, + { 0x320e, "\x00\x28\x11\x00\x11\x61\x00\x29" }, + { 0x320f, "\x00\x28\x11\x02\x11\x61\x00\x29" }, + { 0x3210, "\x00\x28\x11\x03\x11\x61\x00\x29" }, + { 0x3211, "\x00\x28\x11\x05\x11\x61\x00\x29" }, + { 0x3212, "\x00\x28\x11\x06\x11\x61\x00\x29" }, + { 0x3213, "\x00\x28\x11\x07\x11\x61\x00\x29" }, + { 0x3214, "\x00\x28\x11\x09\x11\x61\x00\x29" }, + { 0x3215, "\x00\x28\x11\x0b\x11\x61\x00\x29" }, + { 0x3216, "\x00\x28\x11\x0c\x11\x61\x00\x29" }, + { 0x3217, "\x00\x28\x11\x0e\x11\x61\x00\x29" }, + { 0x3218, "\x00\x28\x11\x0f\x11\x61\x00\x29" }, + { 0x3219, "\x00\x28\x11\x10\x11\x61\x00\x29" }, + { 0x321a, "\x00\x28\x11\x11\x11\x61\x00\x29" }, + { 0x321b, "\x00\x28\x11\x12\x11\x61\x00\x29" }, + { 0x321c, "\x00\x28\x11\x0c\x11\x6e\x00\x29" }, + { 0x3220, "\x00\x28\x4e\x00\x00\x29" }, + { 0x3221, "\x00\x28\x4e\x8c\x00\x29" }, + { 0x3222, "\x00\x28\x4e\x09\x00\x29" }, + { 0x3223, "\x00\x28\x56\xdb\x00\x29" }, + { 0x3224, "\x00\x28\x4e\x94\x00\x29" }, + { 0x3225, "\x00\x28\x51\x6d\x00\x29" }, + { 0x3226, "\x00\x28\x4e\x03\x00\x29" }, + { 0x3227, "\x00\x28\x51\x6b\x00\x29" }, + { 0x3228, "\x00\x28\x4e\x5d\x00\x29" }, + { 0x3229, "\x00\x28\x53\x41\x00\x29" }, + { 0x322a, "\x00\x28\x67\x08\x00\x29" }, + { 0x322b, "\x00\x28\x70\x6b\x00\x29" }, + { 0x322c, "\x00\x28\x6c\x34\x00\x29" }, + { 0x322d, "\x00\x28\x67\x28\x00\x29" }, + { 0x322e, "\x00\x28\x91\xd1\x00\x29" }, + { 0x322f, "\x00\x28\x57\x1f\x00\x29" }, + { 0x3230, "\x00\x28\x65\xe5\x00\x29" }, + { 0x3231, "\x00\x28\x68\x2a\x00\x29" }, + { 0x3232, "\x00\x28\x67\x09\x00\x29" }, + { 0x3233, "\x00\x28\x79\x3e\x00\x29" }, + { 0x3234, "\x00\x28\x54\x0d\x00\x29" }, + { 0x3235, "\x00\x28\x72\x79\x00\x29" }, + { 0x3236, "\x00\x28\x8c\xa1\x00\x29" }, + { 0x3237, "\x00\x28\x79\x5d\x00\x29" }, + { 0x3238, "\x00\x28\x52\xb4\x00\x29" }, + { 0x3239, "\x00\x28\x4e\xe3\x00\x29" }, + { 0x323a, "\x00\x28\x54\x7c\x00\x29" }, + { 0x323b, "\x00\x28\x5b\x66\x00\x29" }, + { 0x323c, "\x00\x28\x76\xe3\x00\x29" }, + { 0x323d, "\x00\x28\x4f\x01\x00\x29" }, + { 0x323e, "\x00\x28\x8c\xc7\x00\x29" }, + { 0x323f, "\x00\x28\x53\x54\x00\x29" }, + { 0x3240, "\x00\x28\x79\x6d\x00\x29" }, + { 0x3241, "\x00\x28\x4f\x11\x00\x29" }, + { 0x3242, "\x00\x28\x81\xea\x00\x29" }, + { 0x3243, "\x00\x28\x81\xf3\x00\x29" }, + { 0x3260, "\x11\x00" }, + { 0x3261, "\x11\x02" }, + { 0x3262, "\x11\x03" }, + { 0x3263, "\x11\x05" }, + { 0x3264, "\x11\x06" }, + { 0x3265, "\x11\x07" }, + { 0x3266, "\x11\x09" }, + { 0x3267, "\x11\x0b" }, + { 0x3268, "\x11\x0c" }, + { 0x3269, "\x11\x0e" }, + { 0x326a, "\x11\x0f" }, + { 0x326b, "\x11\x10" }, + { 0x326c, "\x11\x11" }, + { 0x326d, "\x11\x12" }, + { 0x326e, "\x11\x00\x11\x61" }, + { 0x326f, "\x11\x02\x11\x61" }, + { 0x3270, "\x11\x03\x11\x61" }, + { 0x3271, "\x11\x05\x11\x61" }, + { 0x3272, "\x11\x06\x11\x61" }, + { 0x3273, "\x11\x07\x11\x61" }, + { 0x3274, "\x11\x09\x11\x61" }, + { 0x3275, "\x11\x0b\x11\x61" }, + { 0x3276, "\x11\x0c\x11\x61" }, + { 0x3277, "\x11\x0e\x11\x61" }, + { 0x3278, "\x11\x0f\x11\x61" }, + { 0x3279, "\x11\x10\x11\x61" }, + { 0x327a, "\x11\x11\x11\x61" }, + { 0x327b, "\x11\x12\x11\x61" }, + { 0x3280, "\x4e\x00" }, + { 0x3281, "\x4e\x8c" }, + { 0x3282, "\x4e\x09" }, + { 0x3283, "\x56\xdb" }, + { 0x3284, "\x4e\x94" }, + { 0x3285, "\x51\x6d" }, + { 0x3286, "\x4e\x03" }, + { 0x3287, "\x51\x6b" }, + { 0x3288, "\x4e\x5d" }, + { 0x3289, "\x53\x41" }, + { 0x328a, "\x67\x08" }, + { 0x328b, "\x70\x6b" }, + { 0x328c, "\x6c\x34" }, + { 0x328d, "\x67\x28" }, + { 0x328e, "\x91\xd1" }, + { 0x328f, "\x57\x1f" }, + { 0x3290, "\x65\xe5" }, + { 0x3291, "\x68\x2a" }, + { 0x3292, "\x67\x09" }, + { 0x3293, "\x79\x3e" }, + { 0x3294, "\x54\x0d" }, + { 0x3295, "\x72\x79" }, + { 0x3296, "\x8c\xa1" }, + { 0x3297, "\x79\x5d" }, + { 0x3298, "\x52\xb4" }, + { 0x3299, "\x79\xd8" }, + { 0x329a, "\x75\x37" }, + { 0x329b, "\x59\x73" }, + { 0x329c, "\x90\x69" }, + { 0x329d, "\x51\x2a" }, + { 0x329e, "\x53\x70" }, + { 0x329f, "\x6c\xe8" }, + { 0x32a0, "\x98\x05" }, + { 0x32a1, "\x4f\x11" }, + { 0x32a2, "\x51\x99" }, + { 0x32a3, "\x6b\x63" }, + { 0x32a4, "\x4e\x0a" }, + { 0x32a5, "\x4e\x2d" }, + { 0x32a6, "\x4e\x0b" }, + { 0x32a7, "\x5d\xe6" }, + { 0x32a8, "\x53\xf3" }, + { 0x32a9, "\x53\x3b" }, + { 0x32aa, "\x5b\x97" }, + { 0x32ab, "\x5b\x66" }, + { 0x32ac, "\x76\xe3" }, + { 0x32ad, "\x4f\x01" }, + { 0x32ae, "\x8c\xc7" }, + { 0x32af, "\x53\x54" }, + { 0x32b0, "\x59\x1c" }, + { 0x32c0, "\x00\x31\x67\x08" }, + { 0x32c1, "\x00\x32\x67\x08" }, + { 0x32c2, "\x00\x33\x67\x08" }, + { 0x32c3, "\x00\x34\x67\x08" }, + { 0x32c4, "\x00\x35\x67\x08" }, + { 0x32c5, "\x00\x36\x67\x08" }, + { 0x32c6, "\x00\x37\x67\x08" }, + { 0x32c7, "\x00\x38\x67\x08" }, + { 0x32c8, "\x00\x39\x67\x08" }, + { 0x32c9, "\x00\x31\x00\x30\x67\x08" }, + { 0x32ca, "\x00\x31\x00\x31\x67\x08" }, + { 0x32cb, "\x00\x31\x00\x32\x67\x08" }, + { 0x32d0, "\x30\xa2" }, + { 0x32d1, "\x30\xa4" }, + { 0x32d2, "\x30\xa6" }, + { 0x32d3, "\x30\xa8" }, + { 0x32d4, "\x30\xaa" }, + { 0x32d5, "\x30\xab" }, + { 0x32d6, "\x30\xad" }, + { 0x32d7, "\x30\xaf" }, + { 0x32d8, "\x30\xb1" }, + { 0x32d9, "\x30\xb3" }, + { 0x32da, "\x30\xb5" }, + { 0x32db, "\x30\xb7" }, + { 0x32dc, "\x30\xb9" }, + { 0x32dd, "\x30\xbb" }, + { 0x32de, "\x30\xbd" }, + { 0x32df, "\x30\xbf" }, + { 0x32e0, "\x30\xc1" }, + { 0x32e1, "\x30\xc4" }, + { 0x32e2, "\x30\xc6" }, + { 0x32e3, "\x30\xc8" }, + { 0x32e4, "\x30\xca" }, + { 0x32e5, "\x30\xcb" }, + { 0x32e6, "\x30\xcc" }, + { 0x32e7, "\x30\xcd" }, + { 0x32e8, "\x30\xce" }, + { 0x32e9, "\x30\xcf" }, + { 0x32ea, "\x30\xd2" }, + { 0x32eb, "\x30\xd5" }, + { 0x32ec, "\x30\xd8" }, + { 0x32ed, "\x30\xdb" }, + { 0x32ee, "\x30\xde" }, + { 0x32ef, "\x30\xdf" }, + { 0x32f0, "\x30\xe0" }, + { 0x32f1, "\x30\xe1" }, + { 0x32f2, "\x30\xe2" }, + { 0x32f3, "\x30\xe4" }, + { 0x32f4, "\x30\xe6" }, + { 0x32f5, "\x30\xe8" }, + { 0x32f6, "\x30\xe9" }, + { 0x32f7, "\x30\xea" }, + { 0x32f8, "\x30\xeb" }, + { 0x32f9, "\x30\xec" }, + { 0x32fa, "\x30\xed" }, + { 0x32fb, "\x30\xef" }, + { 0x32fc, "\x30\xf0" }, + { 0x32fd, "\x30\xf1" }, + { 0x32fe, "\x30\xf2" }, + { 0x3300, "\x30\xa2\x30\xd1\x30\xfc\x30\xc8" }, + { 0x3301, "\x30\xa2\x30\xeb\x30\xd5\x30\xa1" }, + { 0x3302, "\x30\xa2\x30\xf3\x30\xda\x30\xa2" }, + { 0x3303, "\x30\xa2\x30\xfc\x30\xeb" }, + { 0x3304, "\x30\xa4\x30\xcb\x30\xf3\x30\xb0" }, + { 0x3305, "\x30\xa4\x30\xf3\x30\xc1" }, + { 0x3306, "\x30\xa6\x30\xa9\x30\xf3" }, + { 0x3307, "\x30\xa8\x30\xb9\x30\xaf\x30\xfc\x30\xc9" }, + { 0x3308, "\x30\xa8\x30\xfc\x30\xab\x30\xfc" }, + { 0x3309, "\x30\xaa\x30\xf3\x30\xb9" }, + { 0x330a, "\x30\xaa\x30\xfc\x30\xe0" }, + { 0x330b, "\x30\xab\x30\xa4\x30\xea" }, + { 0x330c, "\x30\xab\x30\xe9\x30\xc3\x30\xc8" }, + { 0x330d, "\x30\xab\x30\xed\x30\xea\x30\xfc" }, + { 0x330e, "\x30\xac\x30\xed\x30\xf3" }, + { 0x330f, "\x30\xac\x30\xf3\x30\xde" }, + { 0x3310, "\x30\xae\x30\xac" }, + { 0x3311, "\x30\xae\x30\xcb\x30\xfc" }, + { 0x3312, "\x30\xad\x30\xe5\x30\xea\x30\xfc" }, + { 0x3313, "\x30\xae\x30\xeb\x30\xc0\x30\xfc" }, + { 0x3314, "\x30\xad\x30\xed" }, + { 0x3315, "\x30\xad\x30\xed\x30\xb0\x30\xe9\x30\xe0" }, + { 0x3316, "\x30\xad\x30\xed\x30\xe1\x30\xfc\x30\xc8\x30\xeb" }, + { 0x3317, "\x30\xad\x30\xed\x30\xef\x30\xc3\x30\xc8" }, + { 0x3318, "\x30\xb0\x30\xe9\x30\xe0" }, + { 0x3319, "\x30\xb0\x30\xe9\x30\xe0\x30\xc8\x30\xf3" }, + { 0x331a, "\x30\xaf\x30\xeb\x30\xbc\x30\xa4\x30\xed" }, + { 0x331b, "\x30\xaf\x30\xed\x30\xfc\x30\xcd" }, + { 0x331c, "\x30\xb1\x30\xfc\x30\xb9" }, + { 0x331d, "\x30\xb3\x30\xeb\x30\xca" }, + { 0x331e, "\x30\xb3\x30\xfc\x30\xdd" }, + { 0x331f, "\x30\xb5\x30\xa4\x30\xaf\x30\xeb" }, + { 0x3320, "\x30\xb5\x30\xf3\x30\xc1\x30\xfc\x30\xe0" }, + { 0x3321, "\x30\xb7\x30\xea\x30\xf3\x30\xb0" }, + { 0x3322, "\x30\xbb\x30\xf3\x30\xc1" }, + { 0x3323, "\x30\xbb\x30\xf3\x30\xc8" }, + { 0x3324, "\x30\xc0\x30\xfc\x30\xb9" }, + { 0x3325, "\x30\xc7\x30\xb7" }, + { 0x3326, "\x30\xc9\x30\xeb" }, + { 0x3327, "\x30\xc8\x30\xf3" }, + { 0x3328, "\x30\xca\x30\xce" }, + { 0x3329, "\x30\xce\x30\xc3\x30\xc8" }, + { 0x332a, "\x30\xcf\x30\xa4\x30\xc4" }, + { 0x332b, "\x30\xd1\x30\xfc\x30\xbb\x30\xf3\x30\xc8" }, + { 0x332c, "\x30\xd1\x30\xfc\x30\xc4" }, + { 0x332d, "\x30\xd0\x30\xfc\x30\xec\x30\xeb" }, + { 0x332e, "\x30\xd4\x30\xa2\x30\xb9\x30\xc8\x30\xeb" }, + { 0x332f, "\x30\xd4\x30\xaf\x30\xeb" }, + { 0x3330, "\x30\xd4\x30\xb3" }, + { 0x3331, "\x30\xd3\x30\xeb" }, + { 0x3332, "\x30\xd5\x30\xa1\x30\xe9\x30\xc3\x30\xc9" }, + { 0x3333, "\x30\xd5\x30\xa3\x30\xfc\x30\xc8" }, + { 0x3334, "\x30\xd6\x30\xc3\x30\xb7\x30\xa7\x30\xeb" }, + { 0x3335, "\x30\xd5\x30\xe9\x30\xf3" }, + { 0x3336, "\x30\xd8\x30\xaf\x30\xbf\x30\xfc\x30\xeb" }, + { 0x3337, "\x30\xda\x30\xbd" }, + { 0x3338, "\x30\xda\x30\xcb\x30\xd2" }, + { 0x3339, "\x30\xd8\x30\xeb\x30\xc4" }, + { 0x333a, "\x30\xda\x30\xf3\x30\xb9" }, + { 0x333b, "\x30\xda\x30\xfc\x30\xb8" }, + { 0x333c, "\x30\xd9\x30\xfc\x30\xbf" }, + { 0x333d, "\x30\xdd\x30\xa4\x30\xf3\x30\xc8" }, + { 0x333e, "\x30\xdc\x30\xeb\x30\xc8" }, + { 0x333f, "\x30\xdb\x30\xf3" }, + { 0x3340, "\x30\xdd\x30\xf3\x30\xc9" }, + { 0x3341, "\x30\xdb\x30\xfc\x30\xeb" }, + { 0x3342, "\x30\xdb\x30\xfc\x30\xf3" }, + { 0x3343, "\x30\xde\x30\xa4\x30\xaf\x30\xed" }, + { 0x3344, "\x30\xde\x30\xa4\x30\xeb" }, + { 0x3345, "\x30\xde\x30\xc3\x30\xcf" }, + { 0x3346, "\x30\xde\x30\xeb\x30\xaf" }, + { 0x3347, "\x30\xde\x30\xf3\x30\xb7\x30\xe7\x30\xf3" }, + { 0x3348, "\x30\xdf\x30\xaf\x30\xed\x30\xf3" }, + { 0x3349, "\x30\xdf\x30\xea" }, + { 0x334a, "\x30\xdf\x30\xea\x30\xd0\x30\xfc\x30\xeb" }, + { 0x334b, "\x30\xe1\x30\xac" }, + { 0x334c, "\x30\xe1\x30\xac\x30\xc8\x30\xf3" }, + { 0x334d, "\x30\xe1\x30\xfc\x30\xc8\x30\xeb" }, + { 0x334e, "\x30\xe4\x30\xfc\x30\xc9" }, + { 0x334f, "\x30\xe4\x30\xfc\x30\xeb" }, + { 0x3350, "\x30\xe6\x30\xa2\x30\xf3" }, + { 0x3351, "\x30\xea\x30\xc3\x30\xc8\x30\xeb" }, + { 0x3352, "\x30\xea\x30\xe9" }, + { 0x3353, "\x30\xeb\x30\xd4\x30\xfc" }, + { 0x3354, "\x30\xeb\x30\xfc\x30\xd6\x30\xeb" }, + { 0x3355, "\x30\xec\x30\xe0" }, + { 0x3356, "\x30\xec\x30\xf3\x30\xc8\x30\xb2\x30\xf3" }, + { 0x3357, "\x30\xef\x30\xc3\x30\xc8" }, + { 0x3358, "\x00\x30\x70\xb9" }, + { 0x3359, "\x00\x31\x70\xb9" }, + { 0x335a, "\x00\x32\x70\xb9" }, + { 0x335b, "\x00\x33\x70\xb9" }, + { 0x335c, "\x00\x34\x70\xb9" }, + { 0x335d, "\x00\x35\x70\xb9" }, + { 0x335e, "\x00\x36\x70\xb9" }, + { 0x335f, "\x00\x37\x70\xb9" }, + { 0x3360, "\x00\x38\x70\xb9" }, + { 0x3361, "\x00\x39\x70\xb9" }, + { 0x3362, "\x00\x31\x00\x30\x70\xb9" }, + { 0x3363, "\x00\x31\x00\x31\x70\xb9" }, + { 0x3364, "\x00\x31\x00\x32\x70\xb9" }, + { 0x3365, "\x00\x31\x00\x33\x70\xb9" }, + { 0x3366, "\x00\x31\x00\x34\x70\xb9" }, + { 0x3367, "\x00\x31\x00\x35\x70\xb9" }, + { 0x3368, "\x00\x31\x00\x36\x70\xb9" }, + { 0x3369, "\x00\x31\x00\x37\x70\xb9" }, + { 0x336a, "\x00\x31\x00\x38\x70\xb9" }, + { 0x336b, "\x00\x31\x00\x39\x70\xb9" }, + { 0x336c, "\x00\x32\x00\x30\x70\xb9" }, + { 0x336d, "\x00\x32\x00\x31\x70\xb9" }, + { 0x336e, "\x00\x32\x00\x32\x70\xb9" }, + { 0x336f, "\x00\x32\x00\x33\x70\xb9" }, + { 0x3370, "\x00\x32\x00\x34\x70\xb9" }, + { 0x3371, "\x00\x68\x00\x50\x00\x61" }, + { 0x3372, "\x00\x64\x00\x61" }, + { 0x3373, "\x00\x41\x00\x55" }, + { 0x3374, "\x00\x62\x00\x61\x00\x72" }, + { 0x3375, "\x00\x6f\x00\x56" }, + { 0x3376, "\x00\x70\x00\x63" }, + { 0x337b, "\x5e\x73\x62\x10" }, + { 0x337c, "\x66\x2d\x54\x8c" }, + { 0x337d, "\x59\x27\x6b\x63" }, + { 0x337e, "\x66\x0e\x6c\xbb" }, + { 0x337f, "\x68\x2a\x5f\x0f\x4f\x1a\x79\x3e" }, + { 0x3380, "\x00\x70\x00\x41" }, + { 0x3381, "\x00\x6e\x00\x41" }, + { 0x3382, "\x03\xbc\x00\x41" }, + { 0x3383, "\x00\x6d\x00\x41" }, + { 0x3384, "\x00\x6b\x00\x41" }, + { 0x3385, "\x00\x4b\x00\x42" }, + { 0x3386, "\x00\x4d\x00\x42" }, + { 0x3387, "\x00\x47\x00\x42" }, + { 0x3388, "\x00\x63\x00\x61\x00\x6c" }, + { 0x3389, "\x00\x6b\x00\x63\x00\x61\x00\x6c" }, + { 0x338a, "\x00\x70\x00\x46" }, + { 0x338b, "\x00\x6e\x00\x46" }, + { 0x338c, "\x03\xbc\x00\x46" }, + { 0x338d, "\x03\xbc\x00\x67" }, + { 0x338e, "\x00\x6d\x00\x67" }, + { 0x338f, "\x00\x6b\x00\x67" }, + { 0x3390, "\x00\x48\x00\x7a" }, + { 0x3391, "\x00\x6b\x00\x48\x00\x7a" }, + { 0x3392, "\x00\x4d\x00\x48\x00\x7a" }, + { 0x3393, "\x00\x47\x00\x48\x00\x7a" }, + { 0x3394, "\x00\x54\x00\x48\x00\x7a" }, + { 0x3395, "\x03\xbc\x21\x13" }, + { 0x3396, "\x00\x6d\x21\x13" }, + { 0x3397, "\x00\x64\x21\x13" }, + { 0x3398, "\x00\x6b\x21\x13" }, + { 0x3399, "\x00\x66\x00\x6d" }, + { 0x339a, "\x00\x6e\x00\x6d" }, + { 0x339b, "\x03\xbc\x00\x6d" }, + { 0x339c, "\x00\x6d\x00\x6d" }, + { 0x339d, "\x00\x63\x00\x6d" }, + { 0x339e, "\x00\x6b\x00\x6d" }, + { 0x339f, "\x00\x6d\x00\x6d\x00\xb2" }, + { 0x33a0, "\x00\x63\x00\x6d\x00\xb2" }, + { 0x33a1, "\x00\x6d\x00\xb2" }, + { 0x33a2, "\x00\x6b\x00\x6d\x00\xb2" }, + { 0x33a3, "\x00\x6d\x00\x6d\x00\xb3" }, + { 0x33a4, "\x00\x63\x00\x6d\x00\xb3" }, + { 0x33a5, "\x00\x6d\x00\xb3" }, + { 0x33a6, "\x00\x6b\x00\x6d\x00\xb3" }, + { 0x33a7, "\x00\x6d\x22\x15\x00\x73" }, + { 0x33a8, "\x00\x6d\x22\x15\x00\x73\x00\xb2" }, + { 0x33a9, "\x00\x50\x00\x61" }, + { 0x33aa, "\x00\x6b\x00\x50\x00\x61" }, + { 0x33ab, "\x00\x4d\x00\x50\x00\x61" }, + { 0x33ac, "\x00\x47\x00\x50\x00\x61" }, + { 0x33ad, "\x00\x72\x00\x61\x00\x64" }, + { 0x33ae, "\x00\x72\x00\x61\x00\x64\x22\x15\x00\x73" }, + { 0x33af, "\x00\x72\x00\x61\x00\x64\x22\x15\x00\x73\x00\xb2" }, + { 0x33b0, "\x00\x70\x00\x73" }, + { 0x33b1, "\x00\x6e\x00\x73" }, + { 0x33b2, "\x03\xbc\x00\x73" }, + { 0x33b3, "\x00\x6d\x00\x73" }, + { 0x33b4, "\x00\x70\x00\x56" }, + { 0x33b5, "\x00\x6e\x00\x56" }, + { 0x33b6, "\x03\xbc\x00\x56" }, + { 0x33b7, "\x00\x6d\x00\x56" }, + { 0x33b8, "\x00\x6b\x00\x56" }, + { 0x33b9, "\x00\x4d\x00\x56" }, + { 0x33ba, "\x00\x70\x00\x57" }, + { 0x33bb, "\x00\x6e\x00\x57" }, + { 0x33bc, "\x03\xbc\x00\x57" }, + { 0x33bd, "\x00\x6d\x00\x57" }, + { 0x33be, "\x00\x6b\x00\x57" }, + { 0x33bf, "\x00\x4d\x00\x57" }, + { 0x33c0, "\x00\x6b\x03\xa9" }, + { 0x33c1, "\x00\x4d\x03\xa9" }, + { 0x33c2, "\x00\x61\x00\x2e\x00\x6d\x00\x2e" }, + { 0x33c3, "\x00\x42\x00\x71" }, + { 0x33c4, "\x00\x63\x00\x63" }, + { 0x33c5, "\x00\x63\x00\x64" }, + { 0x33c6, "\x00\x43\x22\x15\x00\x6b\x00\x67" }, + { 0x33c7, "\x00\x43\x00\x6f\x00\x2e" }, + { 0x33c8, "\x00\x64\x00\x42" }, + { 0x33c9, "\x00\x47\x00\x79" }, + { 0x33ca, "\x00\x68\x00\x61" }, + { 0x33cb, "\x00\x48\x00\x50" }, + { 0x33cc, "\x00\x69\x00\x6e" }, + { 0x33cd, "\x00\x4b\x00\x4b" }, + { 0x33ce, "\x00\x4b\x00\x4d" }, + { 0x33cf, "\x00\x6b\x00\x74" }, + { 0x33d0, "\x00\x6c\x00\x6d" }, + { 0x33d1, "\x00\x6c\x00\x6e" }, + { 0x33d2, "\x00\x6c\x00\x6f\x00\x67" }, + { 0x33d3, "\x00\x6c\x00\x78" }, + { 0x33d4, "\x00\x6d\x00\x62" }, + { 0x33d5, "\x00\x6d\x00\x69\x00\x6c" }, + { 0x33d6, "\x00\x6d\x00\x6f\x00\x6c" }, + { 0x33d7, "\x00\x50\x00\x48" }, + { 0x33d8, "\x00\x70\x00\x2e\x00\x6d\x00\x2e" }, + { 0x33d9, "\x00\x50\x00\x50\x00\x4d" }, + { 0x33da, "\x00\x50\x00\x52" }, + { 0x33db, "\x00\x73\x00\x72" }, + { 0x33dc, "\x00\x53\x00\x76" }, + { 0x33dd, "\x00\x57\x00\x62" }, + { 0x33e0, "\x00\x31\x65\xe5" }, + { 0x33e1, "\x00\x32\x65\xe5" }, + { 0x33e2, "\x00\x33\x65\xe5" }, + { 0x33e3, "\x00\x34\x65\xe5" }, + { 0x33e4, "\x00\x35\x65\xe5" }, + { 0x33e5, "\x00\x36\x65\xe5" }, + { 0x33e6, "\x00\x37\x65\xe5" }, + { 0x33e7, "\x00\x38\x65\xe5" }, + { 0x33e8, "\x00\x39\x65\xe5" }, + { 0x33e9, "\x00\x31\x00\x30\x65\xe5" }, + { 0x33ea, "\x00\x31\x00\x31\x65\xe5" }, + { 0x33eb, "\x00\x31\x00\x32\x65\xe5" }, + { 0x33ec, "\x00\x31\x00\x33\x65\xe5" }, + { 0x33ed, "\x00\x31\x00\x34\x65\xe5" }, + { 0x33ee, "\x00\x31\x00\x35\x65\xe5" }, + { 0x33ef, "\x00\x31\x00\x36\x65\xe5" }, + { 0x33f0, "\x00\x31\x00\x37\x65\xe5" }, + { 0x33f1, "\x00\x31\x00\x38\x65\xe5" }, + { 0x33f2, "\x00\x31\x00\x39\x65\xe5" }, + { 0x33f3, "\x00\x32\x00\x30\x65\xe5" }, + { 0x33f4, "\x00\x32\x00\x31\x65\xe5" }, + { 0x33f5, "\x00\x32\x00\x32\x65\xe5" }, + { 0x33f6, "\x00\x32\x00\x33\x65\xe5" }, + { 0x33f7, "\x00\x32\x00\x34\x65\xe5" }, + { 0x33f8, "\x00\x32\x00\x35\x65\xe5" }, + { 0x33f9, "\x00\x32\x00\x36\x65\xe5" }, + { 0x33fa, "\x00\x32\x00\x37\x65\xe5" }, + { 0x33fb, "\x00\x32\x00\x38\x65\xe5" }, + { 0x33fc, "\x00\x32\x00\x39\x65\xe5" }, + { 0x33fd, "\x00\x33\x00\x30\x65\xe5" }, + { 0x33fe, "\x00\x33\x00\x31\x65\xe5" }, + { 0xfb00, "\x00\x66\x00\x66" }, + { 0xfb01, "\x00\x66\x00\x69" }, + { 0xfb02, "\x00\x66\x00\x6c" }, + { 0xfb03, "\x00\x66\x00\x66\x00\x69" }, + { 0xfb04, "\x00\x66\x00\x66\x00\x6c" }, + { 0xfb05, "\x01\x7f\x00\x74" }, + { 0xfb06, "\x00\x73\x00\x74" }, + { 0xfb13, "\x05\x74\x05\x76" }, + { 0xfb14, "\x05\x74\x05\x65" }, + { 0xfb15, "\x05\x74\x05\x6b" }, + { 0xfb16, "\x05\x7e\x05\x76" }, + { 0xfb17, "\x05\x74\x05\x6d" }, + { 0xfb20, "\x05\xe2" }, + { 0xfb21, "\x05\xd0" }, + { 0xfb22, "\x05\xd3" }, + { 0xfb23, "\x05\xd4" }, + { 0xfb24, "\x05\xdb" }, + { 0xfb25, "\x05\xdc" }, + { 0xfb26, "\x05\xdd" }, + { 0xfb27, "\x05\xe8" }, + { 0xfb28, "\x05\xea" }, + { 0xfb29, "\x00\x2b" }, + { 0xfb4f, "\x05\xd0\x05\xdc" }, + { 0xfb50, "\x06\x71" }, + { 0xfb51, "\x06\x71" }, + { 0xfb52, "\x06\x7b" }, + { 0xfb53, "\x06\x7b" }, + { 0xfb54, "\x06\x7b" }, + { 0xfb55, "\x06\x7b" }, + { 0xfb56, "\x06\x7e" }, + { 0xfb57, "\x06\x7e" }, + { 0xfb58, "\x06\x7e" }, + { 0xfb59, "\x06\x7e" }, + { 0xfb5a, "\x06\x80" }, + { 0xfb5b, "\x06\x80" }, + { 0xfb5c, "\x06\x80" }, + { 0xfb5d, "\x06\x80" }, + { 0xfb5e, "\x06\x7a" }, + { 0xfb5f, "\x06\x7a" }, + { 0xfb60, "\x06\x7a" }, + { 0xfb61, "\x06\x7a" }, + { 0xfb62, "\x06\x7f" }, + { 0xfb63, "\x06\x7f" }, + { 0xfb64, "\x06\x7f" }, + { 0xfb65, "\x06\x7f" }, + { 0xfb66, "\x06\x79" }, + { 0xfb67, "\x06\x79" }, + { 0xfb68, "\x06\x79" }, + { 0xfb69, "\x06\x79" }, + { 0xfb6a, "\x06\xa4" }, + { 0xfb6b, "\x06\xa4" }, + { 0xfb6c, "\x06\xa4" }, + { 0xfb6d, "\x06\xa4" }, + { 0xfb6e, "\x06\xa6" }, + { 0xfb6f, "\x06\xa6" }, + { 0xfb70, "\x06\xa6" }, + { 0xfb71, "\x06\xa6" }, + { 0xfb72, "\x06\x84" }, + { 0xfb73, "\x06\x84" }, + { 0xfb74, "\x06\x84" }, + { 0xfb75, "\x06\x84" }, + { 0xfb76, "\x06\x83" }, + { 0xfb77, "\x06\x83" }, + { 0xfb78, "\x06\x83" }, + { 0xfb79, "\x06\x83" }, + { 0xfb7a, "\x06\x86" }, + { 0xfb7b, "\x06\x86" }, + { 0xfb7c, "\x06\x86" }, + { 0xfb7d, "\x06\x86" }, + { 0xfb7e, "\x06\x87" }, + { 0xfb7f, "\x06\x87" }, + { 0xfb80, "\x06\x87" }, + { 0xfb81, "\x06\x87" }, + { 0xfb82, "\x06\x8d" }, + { 0xfb83, "\x06\x8d" }, + { 0xfb84, "\x06\x8c" }, + { 0xfb85, "\x06\x8c" }, + { 0xfb86, "\x06\x8e" }, + { 0xfb87, "\x06\x8e" }, + { 0xfb88, "\x06\x88" }, + { 0xfb89, "\x06\x88" }, + { 0xfb8a, "\x06\x98" }, + { 0xfb8b, "\x06\x98" }, + { 0xfb8c, "\x06\x91" }, + { 0xfb8d, "\x06\x91" }, + { 0xfb8e, "\x06\xa9" }, + { 0xfb8f, "\x06\xa9" }, + { 0xfb90, "\x06\xa9" }, + { 0xfb91, "\x06\xa9" }, + { 0xfb92, "\x06\xaf" }, + { 0xfb93, "\x06\xaf" }, + { 0xfb94, "\x06\xaf" }, + { 0xfb95, "\x06\xaf" }, + { 0xfb96, "\x06\xb3" }, + { 0xfb97, "\x06\xb3" }, + { 0xfb98, "\x06\xb3" }, + { 0xfb99, "\x06\xb3" }, + { 0xfb9a, "\x06\xb1" }, + { 0xfb9b, "\x06\xb1" }, + { 0xfb9c, "\x06\xb1" }, + { 0xfb9d, "\x06\xb1" }, + { 0xfb9e, "\x06\xba" }, + { 0xfb9f, "\x06\xba" }, + { 0xfba0, "\x06\xbb" }, + { 0xfba1, "\x06\xbb" }, + { 0xfba2, "\x06\xbb" }, + { 0xfba3, "\x06\xbb" }, + { 0xfba4, "\x06\xc0" }, + { 0xfba5, "\x06\xc0" }, + { 0xfba6, "\x06\xc1" }, + { 0xfba7, "\x06\xc1" }, + { 0xfba8, "\x06\xc1" }, + { 0xfba9, "\x06\xc1" }, + { 0xfbaa, "\x06\xbe" }, + { 0xfbab, "\x06\xbe" }, + { 0xfbac, "\x06\xbe" }, + { 0xfbad, "\x06\xbe" }, + { 0xfbae, "\x06\xd2" }, + { 0xfbaf, "\x06\xd2" }, + { 0xfbb0, "\x06\xd3" }, + { 0xfbb1, "\x06\xd3" }, + { 0xfbd3, "\x06\xad" }, + { 0xfbd4, "\x06\xad" }, + { 0xfbd5, "\x06\xad" }, + { 0xfbd6, "\x06\xad" }, + { 0xfbd7, "\x06\xc7" }, + { 0xfbd8, "\x06\xc7" }, + { 0xfbd9, "\x06\xc6" }, + { 0xfbda, "\x06\xc6" }, + { 0xfbdb, "\x06\xc8" }, + { 0xfbdc, "\x06\xc8" }, + { 0xfbdd, "\x06\x77" }, + { 0xfbde, "\x06\xcb" }, + { 0xfbdf, "\x06\xcb" }, + { 0xfbe0, "\x06\xc5" }, + { 0xfbe1, "\x06\xc5" }, + { 0xfbe2, "\x06\xc9" }, + { 0xfbe3, "\x06\xc9" }, + { 0xfbe4, "\x06\xd0" }, + { 0xfbe5, "\x06\xd0" }, + { 0xfbe6, "\x06\xd0" }, + { 0xfbe7, "\x06\xd0" }, + { 0xfbe8, "\x06\x49" }, + { 0xfbe9, "\x06\x49" }, + { 0xfbea, "\x06\x26\x06\x27" }, + { 0xfbeb, "\x06\x26\x06\x27" }, + { 0xfbec, "\x06\x26\x06\xd5" }, + { 0xfbed, "\x06\x26\x06\xd5" }, + { 0xfbee, "\x06\x26\x06\x48" }, + { 0xfbef, "\x06\x26\x06\x48" }, + { 0xfbf0, "\x06\x26\x06\xc7" }, + { 0xfbf1, "\x06\x26\x06\xc7" }, + { 0xfbf2, "\x06\x26\x06\xc6" }, + { 0xfbf3, "\x06\x26\x06\xc6" }, + { 0xfbf4, "\x06\x26\x06\xc8" }, + { 0xfbf5, "\x06\x26\x06\xc8" }, + { 0xfbf6, "\x06\x26\x06\xd0" }, + { 0xfbf7, "\x06\x26\x06\xd0" }, + { 0xfbf8, "\x06\x26\x06\xd0" }, + { 0xfbf9, "\x06\x26\x06\x49" }, + { 0xfbfa, "\x06\x26\x06\x49" }, + { 0xfbfb, "\x06\x26\x06\x49" }, + { 0xfbfc, "\x06\xcc" }, + { 0xfbfd, "\x06\xcc" }, + { 0xfbfe, "\x06\xcc" }, + { 0xfbff, "\x06\xcc" }, + { 0xfc00, "\x06\x26\x06\x2c" }, + { 0xfc01, "\x06\x26\x06\x2d" }, + { 0xfc02, "\x06\x26\x06\x45" }, + { 0xfc03, "\x06\x26\x06\x49" }, + { 0xfc04, "\x06\x26\x06\x4a" }, + { 0xfc05, "\x06\x28\x06\x2c" }, + { 0xfc06, "\x06\x28\x06\x2d" }, + { 0xfc07, "\x06\x28\x06\x2e" }, + { 0xfc08, "\x06\x28\x06\x45" }, + { 0xfc09, "\x06\x28\x06\x49" }, + { 0xfc0a, "\x06\x28\x06\x4a" }, + { 0xfc0b, "\x06\x2a\x06\x2c" }, + { 0xfc0c, "\x06\x2a\x06\x2d" }, + { 0xfc0d, "\x06\x2a\x06\x2e" }, + { 0xfc0e, "\x06\x2a\x06\x45" }, + { 0xfc0f, "\x06\x2a\x06\x49" }, + { 0xfc10, "\x06\x2a\x06\x4a" }, + { 0xfc11, "\x06\x2b\x06\x2c" }, + { 0xfc12, "\x06\x2b\x06\x45" }, + { 0xfc13, "\x06\x2b\x06\x49" }, + { 0xfc14, "\x06\x2b\x06\x4a" }, + { 0xfc15, "\x06\x2c\x06\x2d" }, + { 0xfc16, "\x06\x2c\x06\x45" }, + { 0xfc17, "\x06\x2d\x06\x2c" }, + { 0xfc18, "\x06\x2d\x06\x45" }, + { 0xfc19, "\x06\x2e\x06\x2c" }, + { 0xfc1a, "\x06\x2e\x06\x2d" }, + { 0xfc1b, "\x06\x2e\x06\x45" }, + { 0xfc1c, "\x06\x33\x06\x2c" }, + { 0xfc1d, "\x06\x33\x06\x2d" }, + { 0xfc1e, "\x06\x33\x06\x2e" }, + { 0xfc1f, "\x06\x33\x06\x45" }, + { 0xfc20, "\x06\x35\x06\x2d" }, + { 0xfc21, "\x06\x35\x06\x45" }, + { 0xfc22, "\x06\x36\x06\x2c" }, + { 0xfc23, "\x06\x36\x06\x2d" }, + { 0xfc24, "\x06\x36\x06\x2e" }, + { 0xfc25, "\x06\x36\x06\x45" }, + { 0xfc26, "\x06\x37\x06\x2d" }, + { 0xfc27, "\x06\x37\x06\x45" }, + { 0xfc28, "\x06\x38\x06\x45" }, + { 0xfc29, "\x06\x39\x06\x2c" }, + { 0xfc2a, "\x06\x39\x06\x45" }, + { 0xfc2b, "\x06\x3a\x06\x2c" }, + { 0xfc2c, "\x06\x3a\x06\x45" }, + { 0xfc2d, "\x06\x41\x06\x2c" }, + { 0xfc2e, "\x06\x41\x06\x2d" }, + { 0xfc2f, "\x06\x41\x06\x2e" }, + { 0xfc30, "\x06\x41\x06\x45" }, + { 0xfc31, "\x06\x41\x06\x49" }, + { 0xfc32, "\x06\x41\x06\x4a" }, + { 0xfc33, "\x06\x42\x06\x2d" }, + { 0xfc34, "\x06\x42\x06\x45" }, + { 0xfc35, "\x06\x42\x06\x49" }, + { 0xfc36, "\x06\x42\x06\x4a" }, + { 0xfc37, "\x06\x43\x06\x27" }, + { 0xfc38, "\x06\x43\x06\x2c" }, + { 0xfc39, "\x06\x43\x06\x2d" }, + { 0xfc3a, "\x06\x43\x06\x2e" }, + { 0xfc3b, "\x06\x43\x06\x44" }, + { 0xfc3c, "\x06\x43\x06\x45" }, + { 0xfc3d, "\x06\x43\x06\x49" }, + { 0xfc3e, "\x06\x43\x06\x4a" }, + { 0xfc3f, "\x06\x44\x06\x2c" }, + { 0xfc40, "\x06\x44\x06\x2d" }, + { 0xfc41, "\x06\x44\x06\x2e" }, + { 0xfc42, "\x06\x44\x06\x45" }, + { 0xfc43, "\x06\x44\x06\x49" }, + { 0xfc44, "\x06\x44\x06\x4a" }, + { 0xfc45, "\x06\x45\x06\x2c" }, + { 0xfc46, "\x06\x45\x06\x2d" }, + { 0xfc47, "\x06\x45\x06\x2e" }, + { 0xfc48, "\x06\x45\x06\x45" }, + { 0xfc49, "\x06\x45\x06\x49" }, + { 0xfc4a, "\x06\x45\x06\x4a" }, + { 0xfc4b, "\x06\x46\x06\x2c" }, + { 0xfc4c, "\x06\x46\x06\x2d" }, + { 0xfc4d, "\x06\x46\x06\x2e" }, + { 0xfc4e, "\x06\x46\x06\x45" }, + { 0xfc4f, "\x06\x46\x06\x49" }, + { 0xfc50, "\x06\x46\x06\x4a" }, + { 0xfc51, "\x06\x47\x06\x2c" }, + { 0xfc52, "\x06\x47\x06\x45" }, + { 0xfc53, "\x06\x47\x06\x49" }, + { 0xfc54, "\x06\x47\x06\x4a" }, + { 0xfc55, "\x06\x4a\x06\x2c" }, + { 0xfc56, "\x06\x4a\x06\x2d" }, + { 0xfc57, "\x06\x4a\x06\x2e" }, + { 0xfc58, "\x06\x4a\x06\x45" }, + { 0xfc59, "\x06\x4a\x06\x49" }, + { 0xfc5a, "\x06\x4a\x06\x4a" }, + { 0xfc5b, "\x06\x30\x06\x70" }, + { 0xfc5c, "\x06\x31\x06\x70" }, + { 0xfc5d, "\x06\x49\x06\x70" }, + { 0xfc5e, "\x00\x20\x06\x51\x06\x4c" }, + { 0xfc5f, "\x00\x20\x06\x51\x06\x4d" }, + { 0xfc60, "\x00\x20\x06\x51\x06\x4e" }, + { 0xfc61, "\x00\x20\x06\x51\x06\x4f" }, + { 0xfc62, "\x00\x20\x06\x51\x06\x50" }, + { 0xfc63, "\x00\x20\x06\x51\x06\x70" }, + { 0xfc64, "\x06\x26\x06\x31" }, + { 0xfc65, "\x06\x26\x06\x32" }, + { 0xfc66, "\x06\x26\x06\x45" }, + { 0xfc67, "\x06\x26\x06\x46" }, + { 0xfc68, "\x06\x26\x06\x49" }, + { 0xfc69, "\x06\x26\x06\x4a" }, + { 0xfc6a, "\x06\x28\x06\x31" }, + { 0xfc6b, "\x06\x28\x06\x32" }, + { 0xfc6c, "\x06\x28\x06\x45" }, + { 0xfc6d, "\x06\x28\x06\x46" }, + { 0xfc6e, "\x06\x28\x06\x49" }, + { 0xfc6f, "\x06\x28\x06\x4a" }, + { 0xfc70, "\x06\x2a\x06\x31" }, + { 0xfc71, "\x06\x2a\x06\x32" }, + { 0xfc72, "\x06\x2a\x06\x45" }, + { 0xfc73, "\x06\x2a\x06\x46" }, + { 0xfc74, "\x06\x2a\x06\x49" }, + { 0xfc75, "\x06\x2a\x06\x4a" }, + { 0xfc76, "\x06\x2b\x06\x31" }, + { 0xfc77, "\x06\x2b\x06\x32" }, + { 0xfc78, "\x06\x2b\x06\x45" }, + { 0xfc79, "\x06\x2b\x06\x46" }, + { 0xfc7a, "\x06\x2b\x06\x49" }, + { 0xfc7b, "\x06\x2b\x06\x4a" }, + { 0xfc7c, "\x06\x41\x06\x49" }, + { 0xfc7d, "\x06\x41\x06\x4a" }, + { 0xfc7e, "\x06\x42\x06\x49" }, + { 0xfc7f, "\x06\x42\x06\x4a" }, + { 0xfc80, "\x06\x43\x06\x27" }, + { 0xfc81, "\x06\x43\x06\x44" }, + { 0xfc82, "\x06\x43\x06\x45" }, + { 0xfc83, "\x06\x43\x06\x49" }, + { 0xfc84, "\x06\x43\x06\x4a" }, + { 0xfc85, "\x06\x44\x06\x45" }, + { 0xfc86, "\x06\x44\x06\x49" }, + { 0xfc87, "\x06\x44\x06\x4a" }, + { 0xfc88, "\x06\x45\x06\x27" }, + { 0xfc89, "\x06\x45\x06\x45" }, + { 0xfc8a, "\x06\x46\x06\x31" }, + { 0xfc8b, "\x06\x46\x06\x32" }, + { 0xfc8c, "\x06\x46\x06\x45" }, + { 0xfc8d, "\x06\x46\x06\x46" }, + { 0xfc8e, "\x06\x46\x06\x49" }, + { 0xfc8f, "\x06\x46\x06\x4a" }, + { 0xfc90, "\x06\x49\x06\x70" }, + { 0xfc91, "\x06\x4a\x06\x31" }, + { 0xfc92, "\x06\x4a\x06\x32" }, + { 0xfc93, "\x06\x4a\x06\x45" }, + { 0xfc94, "\x06\x4a\x06\x46" }, + { 0xfc95, "\x06\x4a\x06\x49" }, + { 0xfc96, "\x06\x4a\x06\x4a" }, + { 0xfc97, "\x06\x26\x06\x2c" }, + { 0xfc98, "\x06\x26\x06\x2d" }, + { 0xfc99, "\x06\x26\x06\x2e" }, + { 0xfc9a, "\x06\x26\x06\x45" }, + { 0xfc9b, "\x06\x26\x06\x47" }, + { 0xfc9c, "\x06\x28\x06\x2c" }, + { 0xfc9d, "\x06\x28\x06\x2d" }, + { 0xfc9e, "\x06\x28\x06\x2e" }, + { 0xfc9f, "\x06\x28\x06\x45" }, + { 0xfca0, "\x06\x28\x06\x47" }, + { 0xfca1, "\x06\x2a\x06\x2c" }, + { 0xfca2, "\x06\x2a\x06\x2d" }, + { 0xfca3, "\x06\x2a\x06\x2e" }, + { 0xfca4, "\x06\x2a\x06\x45" }, + { 0xfca5, "\x06\x2a\x06\x47" }, + { 0xfca6, "\x06\x2b\x06\x45" }, + { 0xfca7, "\x06\x2c\x06\x2d" }, + { 0xfca8, "\x06\x2c\x06\x45" }, + { 0xfca9, "\x06\x2d\x06\x2c" }, + { 0xfcaa, "\x06\x2d\x06\x45" }, + { 0xfcab, "\x06\x2e\x06\x2c" }, + { 0xfcac, "\x06\x2e\x06\x45" }, + { 0xfcad, "\x06\x33\x06\x2c" }, + { 0xfcae, "\x06\x33\x06\x2d" }, + { 0xfcaf, "\x06\x33\x06\x2e" }, + { 0xfcb0, "\x06\x33\x06\x45" }, + { 0xfcb1, "\x06\x35\x06\x2d" }, + { 0xfcb2, "\x06\x35\x06\x2e" }, + { 0xfcb3, "\x06\x35\x06\x45" }, + { 0xfcb4, "\x06\x36\x06\x2c" }, + { 0xfcb5, "\x06\x36\x06\x2d" }, + { 0xfcb6, "\x06\x36\x06\x2e" }, + { 0xfcb7, "\x06\x36\x06\x45" }, + { 0xfcb8, "\x06\x37\x06\x2d" }, + { 0xfcb9, "\x06\x38\x06\x45" }, + { 0xfcba, "\x06\x39\x06\x2c" }, + { 0xfcbb, "\x06\x39\x06\x45" }, + { 0xfcbc, "\x06\x3a\x06\x2c" }, + { 0xfcbd, "\x06\x3a\x06\x45" }, + { 0xfcbe, "\x06\x41\x06\x2c" }, + { 0xfcbf, "\x06\x41\x06\x2d" }, + { 0xfcc0, "\x06\x41\x06\x2e" }, + { 0xfcc1, "\x06\x41\x06\x45" }, + { 0xfcc2, "\x06\x42\x06\x2d" }, + { 0xfcc3, "\x06\x42\x06\x45" }, + { 0xfcc4, "\x06\x43\x06\x2c" }, + { 0xfcc5, "\x06\x43\x06\x2d" }, + { 0xfcc6, "\x06\x43\x06\x2e" }, + { 0xfcc7, "\x06\x43\x06\x44" }, + { 0xfcc8, "\x06\x43\x06\x45" }, + { 0xfcc9, "\x06\x44\x06\x2c" }, + { 0xfcca, "\x06\x44\x06\x2d" }, + { 0xfccb, "\x06\x44\x06\x2e" }, + { 0xfccc, "\x06\x44\x06\x45" }, + { 0xfccd, "\x06\x44\x06\x47" }, + { 0xfcce, "\x06\x45\x06\x2c" }, + { 0xfccf, "\x06\x45\x06\x2d" }, + { 0xfcd0, "\x06\x45\x06\x2e" }, + { 0xfcd1, "\x06\x45\x06\x45" }, + { 0xfcd2, "\x06\x46\x06\x2c" }, + { 0xfcd3, "\x06\x46\x06\x2d" }, + { 0xfcd4, "\x06\x46\x06\x2e" }, + { 0xfcd5, "\x06\x46\x06\x45" }, + { 0xfcd6, "\x06\x46\x06\x47" }, + { 0xfcd7, "\x06\x47\x06\x2c" }, + { 0xfcd8, "\x06\x47\x06\x45" }, + { 0xfcd9, "\x06\x47\x06\x70" }, + { 0xfcda, "\x06\x4a\x06\x2c" }, + { 0xfcdb, "\x06\x4a\x06\x2d" }, + { 0xfcdc, "\x06\x4a\x06\x2e" }, + { 0xfcdd, "\x06\x4a\x06\x45" }, + { 0xfcde, "\x06\x4a\x06\x47" }, + { 0xfcdf, "\x06\x26\x06\x45" }, + { 0xfce0, "\x06\x26\x06\x47" }, + { 0xfce1, "\x06\x28\x06\x45" }, + { 0xfce2, "\x06\x28\x06\x47" }, + { 0xfce3, "\x06\x2a\x06\x45" }, + { 0xfce4, "\x06\x2a\x06\x47" }, + { 0xfce5, "\x06\x2b\x06\x45" }, + { 0xfce6, "\x06\x2b\x06\x47" }, + { 0xfce7, "\x06\x33\x06\x45" }, + { 0xfce8, "\x06\x33\x06\x47" }, + { 0xfce9, "\x06\x34\x06\x45" }, + { 0xfcea, "\x06\x34\x06\x47" }, + { 0xfceb, "\x06\x43\x06\x44" }, + { 0xfcec, "\x06\x43\x06\x45" }, + { 0xfced, "\x06\x44\x06\x45" }, + { 0xfcee, "\x06\x46\x06\x45" }, + { 0xfcef, "\x06\x46\x06\x47" }, + { 0xfcf0, "\x06\x4a\x06\x45" }, + { 0xfcf1, "\x06\x4a\x06\x47" }, + { 0xfcf2, "\x06\x40\x06\x51\x06\x4e" }, + { 0xfcf3, "\x06\x40\x06\x51\x06\x4f" }, + { 0xfcf4, "\x06\x40\x06\x51\x06\x50" }, + { 0xfcf5, "\x06\x37\x06\x49" }, + { 0xfcf6, "\x06\x37\x06\x4a" }, + { 0xfcf7, "\x06\x39\x06\x49" }, + { 0xfcf8, "\x06\x39\x06\x4a" }, + { 0xfcf9, "\x06\x3a\x06\x49" }, + { 0xfcfa, "\x06\x3a\x06\x4a" }, + { 0xfcfb, "\x06\x33\x06\x49" }, + { 0xfcfc, "\x06\x33\x06\x4a" }, + { 0xfcfd, "\x06\x34\x06\x49" }, + { 0xfcfe, "\x06\x34\x06\x4a" }, + { 0xfcff, "\x06\x2d\x06\x49" }, + { 0xfd00, "\x06\x2d\x06\x4a" }, + { 0xfd01, "\x06\x2c\x06\x49" }, + { 0xfd02, "\x06\x2c\x06\x4a" }, + { 0xfd03, "\x06\x2e\x06\x49" }, + { 0xfd04, "\x06\x2e\x06\x4a" }, + { 0xfd05, "\x06\x35\x06\x49" }, + { 0xfd06, "\x06\x35\x06\x4a" }, + { 0xfd07, "\x06\x36\x06\x49" }, + { 0xfd08, "\x06\x36\x06\x4a" }, + { 0xfd09, "\x06\x34\x06\x2c" }, + { 0xfd0a, "\x06\x34\x06\x2d" }, + { 0xfd0b, "\x06\x34\x06\x2e" }, + { 0xfd0c, "\x06\x34\x06\x45" }, + { 0xfd0d, "\x06\x34\x06\x31" }, + { 0xfd0e, "\x06\x33\x06\x31" }, + { 0xfd0f, "\x06\x35\x06\x31" }, + { 0xfd10, "\x06\x36\x06\x31" }, + { 0xfd11, "\x06\x37\x06\x49" }, + { 0xfd12, "\x06\x37\x06\x4a" }, + { 0xfd13, "\x06\x39\x06\x49" }, + { 0xfd14, "\x06\x39\x06\x4a" }, + { 0xfd15, "\x06\x3a\x06\x49" }, + { 0xfd16, "\x06\x3a\x06\x4a" }, + { 0xfd17, "\x06\x33\x06\x49" }, + { 0xfd18, "\x06\x33\x06\x4a" }, + { 0xfd19, "\x06\x34\x06\x49" }, + { 0xfd1a, "\x06\x34\x06\x4a" }, + { 0xfd1b, "\x06\x2d\x06\x49" }, + { 0xfd1c, "\x06\x2d\x06\x4a" }, + { 0xfd1d, "\x06\x2c\x06\x49" }, + { 0xfd1e, "\x06\x2c\x06\x4a" }, + { 0xfd1f, "\x06\x2e\x06\x49" }, + { 0xfd20, "\x06\x2e\x06\x4a" }, + { 0xfd21, "\x06\x35\x06\x49" }, + { 0xfd22, "\x06\x35\x06\x4a" }, + { 0xfd23, "\x06\x36\x06\x49" }, + { 0xfd24, "\x06\x36\x06\x4a" }, + { 0xfd25, "\x06\x34\x06\x2c" }, + { 0xfd26, "\x06\x34\x06\x2d" }, + { 0xfd27, "\x06\x34\x06\x2e" }, + { 0xfd28, "\x06\x34\x06\x45" }, + { 0xfd29, "\x06\x34\x06\x31" }, + { 0xfd2a, "\x06\x33\x06\x31" }, + { 0xfd2b, "\x06\x35\x06\x31" }, + { 0xfd2c, "\x06\x36\x06\x31" }, + { 0xfd2d, "\x06\x34\x06\x2c" }, + { 0xfd2e, "\x06\x34\x06\x2d" }, + { 0xfd2f, "\x06\x34\x06\x2e" }, + { 0xfd30, "\x06\x34\x06\x45" }, + { 0xfd31, "\x06\x33\x06\x47" }, + { 0xfd32, "\x06\x34\x06\x47" }, + { 0xfd33, "\x06\x37\x06\x45" }, + { 0xfd34, "\x06\x33\x06\x2c" }, + { 0xfd35, "\x06\x33\x06\x2d" }, + { 0xfd36, "\x06\x33\x06\x2e" }, + { 0xfd37, "\x06\x34\x06\x2c" }, + { 0xfd38, "\x06\x34\x06\x2d" }, + { 0xfd39, "\x06\x34\x06\x2e" }, + { 0xfd3a, "\x06\x37\x06\x45" }, + { 0xfd3b, "\x06\x38\x06\x45" }, + { 0xfd3c, "\x06\x27\x06\x4b" }, + { 0xfd3d, "\x06\x27\x06\x4b" }, + { 0xfd50, "\x06\x2a\x06\x2c\x06\x45" }, + { 0xfd51, "\x06\x2a\x06\x2d\x06\x2c" }, + { 0xfd52, "\x06\x2a\x06\x2d\x06\x2c" }, + { 0xfd53, "\x06\x2a\x06\x2d\x06\x45" }, + { 0xfd54, "\x06\x2a\x06\x2e\x06\x45" }, + { 0xfd55, "\x06\x2a\x06\x45\x06\x2c" }, + { 0xfd56, "\x06\x2a\x06\x45\x06\x2d" }, + { 0xfd57, "\x06\x2a\x06\x45\x06\x2e" }, + { 0xfd58, "\x06\x2c\x06\x45\x06\x2d" }, + { 0xfd59, "\x06\x2c\x06\x45\x06\x2d" }, + { 0xfd5a, "\x06\x2d\x06\x45\x06\x4a" }, + { 0xfd5b, "\x06\x2d\x06\x45\x06\x49" }, + { 0xfd5c, "\x06\x33\x06\x2d\x06\x2c" }, + { 0xfd5d, "\x06\x33\x06\x2c\x06\x2d" }, + { 0xfd5e, "\x06\x33\x06\x2c\x06\x49" }, + { 0xfd5f, "\x06\x33\x06\x45\x06\x2d" }, + { 0xfd60, "\x06\x33\x06\x45\x06\x2d" }, + { 0xfd61, "\x06\x33\x06\x45\x06\x2c" }, + { 0xfd62, "\x06\x33\x06\x45\x06\x45" }, + { 0xfd63, "\x06\x33\x06\x45\x06\x45" }, + { 0xfd64, "\x06\x35\x06\x2d\x06\x2d" }, + { 0xfd65, "\x06\x35\x06\x2d\x06\x2d" }, + { 0xfd66, "\x06\x35\x06\x45\x06\x45" }, + { 0xfd67, "\x06\x34\x06\x2d\x06\x45" }, + { 0xfd68, "\x06\x34\x06\x2d\x06\x45" }, + { 0xfd69, "\x06\x34\x06\x2c\x06\x4a" }, + { 0xfd6a, "\x06\x34\x06\x45\x06\x2e" }, + { 0xfd6b, "\x06\x34\x06\x45\x06\x2e" }, + { 0xfd6c, "\x06\x34\x06\x45\x06\x45" }, + { 0xfd6d, "\x06\x34\x06\x45\x06\x45" }, + { 0xfd6e, "\x06\x36\x06\x2d\x06\x49" }, + { 0xfd6f, "\x06\x36\x06\x2e\x06\x45" }, + { 0xfd70, "\x06\x36\x06\x2e\x06\x45" }, + { 0xfd71, "\x06\x37\x06\x45\x06\x2d" }, + { 0xfd72, "\x06\x37\x06\x45\x06\x2d" }, + { 0xfd73, "\x06\x37\x06\x45\x06\x45" }, + { 0xfd74, "\x06\x37\x06\x45\x06\x4a" }, + { 0xfd75, "\x06\x39\x06\x2c\x06\x45" }, + { 0xfd76, "\x06\x39\x06\x45\x06\x45" }, + { 0xfd77, "\x06\x39\x06\x45\x06\x45" }, + { 0xfd78, "\x06\x39\x06\x45\x06\x49" }, + { 0xfd79, "\x06\x3a\x06\x45\x06\x45" }, + { 0xfd7a, "\x06\x3a\x06\x45\x06\x4a" }, + { 0xfd7b, "\x06\x3a\x06\x45\x06\x49" }, + { 0xfd7c, "\x06\x41\x06\x2e\x06\x45" }, + { 0xfd7d, "\x06\x41\x06\x2e\x06\x45" }, + { 0xfd7e, "\x06\x42\x06\x45\x06\x2d" }, + { 0xfd7f, "\x06\x42\x06\x45\x06\x45" }, + { 0xfd80, "\x06\x44\x06\x2d\x06\x45" }, + { 0xfd81, "\x06\x44\x06\x2d\x06\x4a" }, + { 0xfd82, "\x06\x44\x06\x2d\x06\x49" }, + { 0xfd83, "\x06\x44\x06\x2c\x06\x2c" }, + { 0xfd84, "\x06\x44\x06\x2c\x06\x2c" }, + { 0xfd85, "\x06\x44\x06\x2e\x06\x45" }, + { 0xfd86, "\x06\x44\x06\x2e\x06\x45" }, + { 0xfd87, "\x06\x44\x06\x45\x06\x2d" }, + { 0xfd88, "\x06\x44\x06\x45\x06\x2d" }, + { 0xfd89, "\x06\x45\x06\x2d\x06\x2c" }, + { 0xfd8a, "\x06\x45\x06\x2d\x06\x45" }, + { 0xfd8b, "\x06\x45\x06\x2d\x06\x4a" }, + { 0xfd8c, "\x06\x45\x06\x2c\x06\x2d" }, + { 0xfd8d, "\x06\x45\x06\x2c\x06\x45" }, + { 0xfd8e, "\x06\x45\x06\x2e\x06\x2c" }, + { 0xfd8f, "\x06\x45\x06\x2e\x06\x45" }, + { 0xfd92, "\x06\x45\x06\x2c\x06\x2e" }, + { 0xfd93, "\x06\x47\x06\x45\x06\x2c" }, + { 0xfd94, "\x06\x47\x06\x45\x06\x45" }, + { 0xfd95, "\x06\x46\x06\x2d\x06\x45" }, + { 0xfd96, "\x06\x46\x06\x2d\x06\x49" }, + { 0xfd97, "\x06\x46\x06\x2c\x06\x45" }, + { 0xfd98, "\x06\x46\x06\x2c\x06\x45" }, + { 0xfd99, "\x06\x46\x06\x2c\x06\x49" }, + { 0xfd9a, "\x06\x46\x06\x45\x06\x4a" }, + { 0xfd9b, "\x06\x46\x06\x45\x06\x49" }, + { 0xfd9c, "\x06\x4a\x06\x45\x06\x45" }, + { 0xfd9d, "\x06\x4a\x06\x45\x06\x45" }, + { 0xfd9e, "\x06\x28\x06\x2e\x06\x4a" }, + { 0xfd9f, "\x06\x2a\x06\x2c\x06\x4a" }, + { 0xfda0, "\x06\x2a\x06\x2c\x06\x49" }, + { 0xfda1, "\x06\x2a\x06\x2e\x06\x4a" }, + { 0xfda2, "\x06\x2a\x06\x2e\x06\x49" }, + { 0xfda3, "\x06\x2a\x06\x45\x06\x4a" }, + { 0xfda4, "\x06\x2a\x06\x45\x06\x49" }, + { 0xfda5, "\x06\x2c\x06\x45\x06\x4a" }, + { 0xfda6, "\x06\x2c\x06\x2d\x06\x49" }, + { 0xfda7, "\x06\x2c\x06\x45\x06\x49" }, + { 0xfda8, "\x06\x33\x06\x2e\x06\x49" }, + { 0xfda9, "\x06\x35\x06\x2d\x06\x4a" }, + { 0xfdaa, "\x06\x34\x06\x2d\x06\x4a" }, + { 0xfdab, "\x06\x36\x06\x2d\x06\x4a" }, + { 0xfdac, "\x06\x44\x06\x2c\x06\x4a" }, + { 0xfdad, "\x06\x44\x06\x45\x06\x4a" }, + { 0xfdae, "\x06\x4a\x06\x2d\x06\x4a" }, + { 0xfdaf, "\x06\x4a\x06\x2c\x06\x4a" }, + { 0xfdb0, "\x06\x4a\x06\x45\x06\x4a" }, + { 0xfdb1, "\x06\x45\x06\x45\x06\x4a" }, + { 0xfdb2, "\x06\x42\x06\x45\x06\x4a" }, + { 0xfdb3, "\x06\x46\x06\x2d\x06\x4a" }, + { 0xfdb4, "\x06\x42\x06\x45\x06\x2d" }, + { 0xfdb5, "\x06\x44\x06\x2d\x06\x45" }, + { 0xfdb6, "\x06\x39\x06\x45\x06\x4a" }, + { 0xfdb7, "\x06\x43\x06\x45\x06\x4a" }, + { 0xfdb8, "\x06\x46\x06\x2c\x06\x2d" }, + { 0xfdb9, "\x06\x45\x06\x2e\x06\x4a" }, + { 0xfdba, "\x06\x44\x06\x2c\x06\x45" }, + { 0xfdbb, "\x06\x43\x06\x45\x06\x45" }, + { 0xfdbc, "\x06\x44\x06\x2c\x06\x45" }, + { 0xfdbd, "\x06\x46\x06\x2c\x06\x2d" }, + { 0xfdbe, "\x06\x2c\x06\x2d\x06\x4a" }, + { 0xfdbf, "\x06\x2d\x06\x2c\x06\x4a" }, + { 0xfdc0, "\x06\x45\x06\x2c\x06\x4a" }, + { 0xfdc1, "\x06\x41\x06\x45\x06\x4a" }, + { 0xfdc2, "\x06\x28\x06\x2d\x06\x4a" }, + { 0xfdc3, "\x06\x43\x06\x45\x06\x45" }, + { 0xfdc4, "\x06\x39\x06\x2c\x06\x45" }, + { 0xfdc5, "\x06\x35\x06\x45\x06\x45" }, + { 0xfdc6, "\x06\x33\x06\x2e\x06\x4a" }, + { 0xfdc7, "\x06\x46\x06\x2c\x06\x4a" }, + { 0xfdf0, "\x06\x35\x06\x44\x06\xd2" }, + { 0xfdf1, "\x06\x42\x06\x44\x06\xd2" }, + { 0xfdf2, "\x06\x27\x06\x44\x06\x44\x06\x47" }, + { 0xfdf3, "\x06\x27\x06\x43\x06\x28\x06\x31" }, + { 0xfdf4, "\x06\x45\x06\x2d\x06\x45\x06\x2f" }, + { 0xfdf5, "\x06\x35\x06\x44\x06\x39\x06\x45" }, + { 0xfdf6, "\x06\x31\x06\x33\x06\x48\x06\x44" }, + { 0xfdf7, "\x06\x39\x06\x44\x06\x4a\x06\x47" }, + { 0xfdf8, "\x06\x48\x06\x33\x06\x44\x06\x45" }, + { 0xfdf9, "\x06\x35\x06\x44\x06\x49" }, + { 0xfdfa, "\x06\x35\x06\x44\x06\x49\x00\x20\x06\x27\x06\x44\x06\x44\x06\x47\x00\x20\x06\x39\x06\x44\x06\x4a\x06\x47\x00\x20\x06\x48\x06\x33\x06\x44\x06\x45" }, + { 0xfdfb, "\x06\x2c\x06\x44\x00\x20\x06\x2c\x06\x44\x06\x27\x06\x44\x06\x47" }, + { 0xfe30, "\x20\x25" }, + { 0xfe31, "\x20\x14" }, + { 0xfe32, "\x20\x13" }, + { 0xfe33, "\x00\x5f" }, + { 0xfe34, "\x00\x5f" }, + { 0xfe35, "\x00\x28" }, + { 0xfe36, "\x00\x29" }, + { 0xfe37, "\x00\x7b" }, + { 0xfe38, "\x00\x7d" }, + { 0xfe39, "\x30\x14" }, + { 0xfe3a, "\x30\x15" }, + { 0xfe3b, "\x30\x10" }, + { 0xfe3c, "\x30\x11" }, + { 0xfe3d, "\x30\x0a" }, + { 0xfe3e, "\x30\x0b" }, + { 0xfe3f, "\x30\x08" }, + { 0xfe40, "\x30\x09" }, + { 0xfe41, "\x30\x0c" }, + { 0xfe42, "\x30\x0d" }, + { 0xfe43, "\x30\x0e" }, + { 0xfe44, "\x30\x0f" }, + { 0xfe49, "\x20\x3e" }, + { 0xfe4a, "\x20\x3e" }, + { 0xfe4b, "\x20\x3e" }, + { 0xfe4c, "\x20\x3e" }, + { 0xfe4d, "\x00\x5f" }, + { 0xfe4e, "\x00\x5f" }, + { 0xfe4f, "\x00\x5f" }, + { 0xfe50, "\x00\x2c" }, + { 0xfe51, "\x30\x01" }, + { 0xfe52, "\x00\x2e" }, + { 0xfe54, "\x00\x3b" }, + { 0xfe55, "\x00\x3a" }, + { 0xfe56, "\x00\x3f" }, + { 0xfe57, "\x00\x21" }, + { 0xfe58, "\x20\x14" }, + { 0xfe59, "\x00\x28" }, + { 0xfe5a, "\x00\x29" }, + { 0xfe5b, "\x00\x7b" }, + { 0xfe5c, "\x00\x7d" }, + { 0xfe5d, "\x30\x14" }, + { 0xfe5e, "\x30\x15" }, + { 0xfe5f, "\x00\x23" }, + { 0xfe60, "\x00\x26" }, + { 0xfe61, "\x00\x2a" }, + { 0xfe62, "\x00\x2b" }, + { 0xfe63, "\x00\x2d" }, + { 0xfe64, "\x00\x3c" }, + { 0xfe65, "\x00\x3e" }, + { 0xfe66, "\x00\x3d" }, + { 0xfe68, "\x00\x5c" }, + { 0xfe69, "\x00\x24" }, + { 0xfe6a, "\x00\x25" }, + { 0xfe6b, "\x00\x40" }, + { 0xfe70, "\x00\x20\x06\x4b" }, + { 0xfe71, "\x06\x40\x06\x4b" }, + { 0xfe72, "\x00\x20\x06\x4c" }, + { 0xfe74, "\x00\x20\x06\x4d" }, + { 0xfe76, "\x00\x20\x06\x4e" }, + { 0xfe77, "\x06\x40\x06\x4e" }, + { 0xfe78, "\x00\x20\x06\x4f" }, + { 0xfe79, "\x06\x40\x06\x4f" }, + { 0xfe7a, "\x00\x20\x06\x50" }, + { 0xfe7b, "\x06\x40\x06\x50" }, + { 0xfe7c, "\x00\x20\x06\x51" }, + { 0xfe7d, "\x06\x40\x06\x51" }, + { 0xfe7e, "\x00\x20\x06\x52" }, + { 0xfe7f, "\x06\x40\x06\x52" }, + { 0xfe80, "\x06\x21" }, + { 0xfe81, "\x06\x22" }, + { 0xfe82, "\x06\x22" }, + { 0xfe83, "\x06\x23" }, + { 0xfe84, "\x06\x23" }, + { 0xfe85, "\x06\x24" }, + { 0xfe86, "\x06\x24" }, + { 0xfe87, "\x06\x25" }, + { 0xfe88, "\x06\x25" }, + { 0xfe89, "\x06\x26" }, + { 0xfe8a, "\x06\x26" }, + { 0xfe8b, "\x06\x26" }, + { 0xfe8c, "\x06\x26" }, + { 0xfe8d, "\x06\x27" }, + { 0xfe8e, "\x06\x27" }, + { 0xfe8f, "\x06\x28" }, + { 0xfe90, "\x06\x28" }, + { 0xfe91, "\x06\x28" }, + { 0xfe92, "\x06\x28" }, + { 0xfe93, "\x06\x29" }, + { 0xfe94, "\x06\x29" }, + { 0xfe95, "\x06\x2a" }, + { 0xfe96, "\x06\x2a" }, + { 0xfe97, "\x06\x2a" }, + { 0xfe98, "\x06\x2a" }, + { 0xfe99, "\x06\x2b" }, + { 0xfe9a, "\x06\x2b" }, + { 0xfe9b, "\x06\x2b" }, + { 0xfe9c, "\x06\x2b" }, + { 0xfe9d, "\x06\x2c" }, + { 0xfe9e, "\x06\x2c" }, + { 0xfe9f, "\x06\x2c" }, + { 0xfea0, "\x06\x2c" }, + { 0xfea1, "\x06\x2d" }, + { 0xfea2, "\x06\x2d" }, + { 0xfea3, "\x06\x2d" }, + { 0xfea4, "\x06\x2d" }, + { 0xfea5, "\x06\x2e" }, + { 0xfea6, "\x06\x2e" }, + { 0xfea7, "\x06\x2e" }, + { 0xfea8, "\x06\x2e" }, + { 0xfea9, "\x06\x2f" }, + { 0xfeaa, "\x06\x2f" }, + { 0xfeab, "\x06\x30" }, + { 0xfeac, "\x06\x30" }, + { 0xfead, "\x06\x31" }, + { 0xfeae, "\x06\x31" }, + { 0xfeaf, "\x06\x32" }, + { 0xfeb0, "\x06\x32" }, + { 0xfeb1, "\x06\x33" }, + { 0xfeb2, "\x06\x33" }, + { 0xfeb3, "\x06\x33" }, + { 0xfeb4, "\x06\x33" }, + { 0xfeb5, "\x06\x34" }, + { 0xfeb6, "\x06\x34" }, + { 0xfeb7, "\x06\x34" }, + { 0xfeb8, "\x06\x34" }, + { 0xfeb9, "\x06\x35" }, + { 0xfeba, "\x06\x35" }, + { 0xfebb, "\x06\x35" }, + { 0xfebc, "\x06\x35" }, + { 0xfebd, "\x06\x36" }, + { 0xfebe, "\x06\x36" }, + { 0xfebf, "\x06\x36" }, + { 0xfec0, "\x06\x36" }, + { 0xfec1, "\x06\x37" }, + { 0xfec2, "\x06\x37" }, + { 0xfec3, "\x06\x37" }, + { 0xfec4, "\x06\x37" }, + { 0xfec5, "\x06\x38" }, + { 0xfec6, "\x06\x38" }, + { 0xfec7, "\x06\x38" }, + { 0xfec8, "\x06\x38" }, + { 0xfec9, "\x06\x39" }, + { 0xfeca, "\x06\x39" }, + { 0xfecb, "\x06\x39" }, + { 0xfecc, "\x06\x39" }, + { 0xfecd, "\x06\x3a" }, + { 0xfece, "\x06\x3a" }, + { 0xfecf, "\x06\x3a" }, + { 0xfed0, "\x06\x3a" }, + { 0xfed1, "\x06\x41" }, + { 0xfed2, "\x06\x41" }, + { 0xfed3, "\x06\x41" }, + { 0xfed4, "\x06\x41" }, + { 0xfed5, "\x06\x42" }, + { 0xfed6, "\x06\x42" }, + { 0xfed7, "\x06\x42" }, + { 0xfed8, "\x06\x42" }, + { 0xfed9, "\x06\x43" }, + { 0xfeda, "\x06\x43" }, + { 0xfedb, "\x06\x43" }, + { 0xfedc, "\x06\x43" }, + { 0xfedd, "\x06\x44" }, + { 0xfede, "\x06\x44" }, + { 0xfedf, "\x06\x44" }, + { 0xfee0, "\x06\x44" }, + { 0xfee1, "\x06\x45" }, + { 0xfee2, "\x06\x45" }, + { 0xfee3, "\x06\x45" }, + { 0xfee4, "\x06\x45" }, + { 0xfee5, "\x06\x46" }, + { 0xfee6, "\x06\x46" }, + { 0xfee7, "\x06\x46" }, + { 0xfee8, "\x06\x46" }, + { 0xfee9, "\x06\x47" }, + { 0xfeea, "\x06\x47" }, + { 0xfeeb, "\x06\x47" }, + { 0xfeec, "\x06\x47" }, + { 0xfeed, "\x06\x48" }, + { 0xfeee, "\x06\x48" }, + { 0xfeef, "\x06\x49" }, + { 0xfef0, "\x06\x49" }, + { 0xfef1, "\x06\x4a" }, + { 0xfef2, "\x06\x4a" }, + { 0xfef3, "\x06\x4a" }, + { 0xfef4, "\x06\x4a" }, + { 0xfef5, "\x06\x44\x06\x22" }, + { 0xfef6, "\x06\x44\x06\x22" }, + { 0xfef7, "\x06\x44\x06\x23" }, + { 0xfef8, "\x06\x44\x06\x23" }, + { 0xfef9, "\x06\x44\x06\x25" }, + { 0xfefa, "\x06\x44\x06\x25" }, + { 0xfefb, "\x06\x44\x06\x27" }, + { 0xfefc, "\x06\x44\x06\x27" }, + { 0xff01, "\x00\x21" }, + { 0xff02, "\x00\x22" }, + { 0xff03, "\x00\x23" }, + { 0xff04, "\x00\x24" }, + { 0xff05, "\x00\x25" }, + { 0xff06, "\x00\x26" }, + { 0xff07, "\x00\x27" }, + { 0xff08, "\x00\x28" }, + { 0xff09, "\x00\x29" }, + { 0xff0a, "\x00\x2a" }, + { 0xff0b, "\x00\x2b" }, + { 0xff0c, "\x00\x2c" }, + { 0xff0d, "\x00\x2d" }, + { 0xff0e, "\x00\x2e" }, + { 0xff0f, "\x00\x2f" }, + { 0xff10, "\x00\x30" }, + { 0xff11, "\x00\x31" }, + { 0xff12, "\x00\x32" }, + { 0xff13, "\x00\x33" }, + { 0xff14, "\x00\x34" }, + { 0xff15, "\x00\x35" }, + { 0xff16, "\x00\x36" }, + { 0xff17, "\x00\x37" }, + { 0xff18, "\x00\x38" }, + { 0xff19, "\x00\x39" }, + { 0xff1a, "\x00\x3a" }, + { 0xff1b, "\x00\x3b" }, + { 0xff1c, "\x00\x3c" }, + { 0xff1d, "\x00\x3d" }, + { 0xff1e, "\x00\x3e" }, + { 0xff1f, "\x00\x3f" }, + { 0xff20, "\x00\x40" }, + { 0xff21, "\x00\x41" }, + { 0xff22, "\x00\x42" }, + { 0xff23, "\x00\x43" }, + { 0xff24, "\x00\x44" }, + { 0xff25, "\x00\x45" }, + { 0xff26, "\x00\x46" }, + { 0xff27, "\x00\x47" }, + { 0xff28, "\x00\x48" }, + { 0xff29, "\x00\x49" }, + { 0xff2a, "\x00\x4a" }, + { 0xff2b, "\x00\x4b" }, + { 0xff2c, "\x00\x4c" }, + { 0xff2d, "\x00\x4d" }, + { 0xff2e, "\x00\x4e" }, + { 0xff2f, "\x00\x4f" }, + { 0xff30, "\x00\x50" }, + { 0xff31, "\x00\x51" }, + { 0xff32, "\x00\x52" }, + { 0xff33, "\x00\x53" }, + { 0xff34, "\x00\x54" }, + { 0xff35, "\x00\x55" }, + { 0xff36, "\x00\x56" }, + { 0xff37, "\x00\x57" }, + { 0xff38, "\x00\x58" }, + { 0xff39, "\x00\x59" }, + { 0xff3a, "\x00\x5a" }, + { 0xff3b, "\x00\x5b" }, + { 0xff3c, "\x00\x5c" }, + { 0xff3d, "\x00\x5d" }, + { 0xff3e, "\x00\x5e" }, + { 0xff3f, "\x00\x5f" }, + { 0xff40, "\x00\x60" }, + { 0xff41, "\x00\x61" }, + { 0xff42, "\x00\x62" }, + { 0xff43, "\x00\x63" }, + { 0xff44, "\x00\x64" }, + { 0xff45, "\x00\x65" }, + { 0xff46, "\x00\x66" }, + { 0xff47, "\x00\x67" }, + { 0xff48, "\x00\x68" }, + { 0xff49, "\x00\x69" }, + { 0xff4a, "\x00\x6a" }, + { 0xff4b, "\x00\x6b" }, + { 0xff4c, "\x00\x6c" }, + { 0xff4d, "\x00\x6d" }, + { 0xff4e, "\x00\x6e" }, + { 0xff4f, "\x00\x6f" }, + { 0xff50, "\x00\x70" }, + { 0xff51, "\x00\x71" }, + { 0xff52, "\x00\x72" }, + { 0xff53, "\x00\x73" }, + { 0xff54, "\x00\x74" }, + { 0xff55, "\x00\x75" }, + { 0xff56, "\x00\x76" }, + { 0xff57, "\x00\x77" }, + { 0xff58, "\x00\x78" }, + { 0xff59, "\x00\x79" }, + { 0xff5a, "\x00\x7a" }, + { 0xff5b, "\x00\x7b" }, + { 0xff5c, "\x00\x7c" }, + { 0xff5d, "\x00\x7d" }, + { 0xff5e, "\x00\x7e" }, + { 0xff61, "\x30\x02" }, + { 0xff62, "\x30\x0c" }, + { 0xff63, "\x30\x0d" }, + { 0xff64, "\x30\x01" }, + { 0xff65, "\x30\xfb" }, + { 0xff66, "\x30\xf2" }, + { 0xff67, "\x30\xa1" }, + { 0xff68, "\x30\xa3" }, + { 0xff69, "\x30\xa5" }, + { 0xff6a, "\x30\xa7" }, + { 0xff6b, "\x30\xa9" }, + { 0xff6c, "\x30\xe3" }, + { 0xff6d, "\x30\xe5" }, + { 0xff6e, "\x30\xe7" }, + { 0xff6f, "\x30\xc3" }, + { 0xff70, "\x30\xfc" }, + { 0xff71, "\x30\xa2" }, + { 0xff72, "\x30\xa4" }, + { 0xff73, "\x30\xa6" }, + { 0xff74, "\x30\xa8" }, + { 0xff75, "\x30\xaa" }, + { 0xff76, "\x30\xab" }, + { 0xff77, "\x30\xad" }, + { 0xff78, "\x30\xaf" }, + { 0xff79, "\x30\xb1" }, + { 0xff7a, "\x30\xb3" }, + { 0xff7b, "\x30\xb5" }, + { 0xff7c, "\x30\xb7" }, + { 0xff7d, "\x30\xb9" }, + { 0xff7e, "\x30\xbb" }, + { 0xff7f, "\x30\xbd" }, + { 0xff80, "\x30\xbf" }, + { 0xff81, "\x30\xc1" }, + { 0xff82, "\x30\xc4" }, + { 0xff83, "\x30\xc6" }, + { 0xff84, "\x30\xc8" }, + { 0xff85, "\x30\xca" }, + { 0xff86, "\x30\xcb" }, + { 0xff87, "\x30\xcc" }, + { 0xff88, "\x30\xcd" }, + { 0xff89, "\x30\xce" }, + { 0xff8a, "\x30\xcf" }, + { 0xff8b, "\x30\xd2" }, + { 0xff8c, "\x30\xd5" }, + { 0xff8d, "\x30\xd8" }, + { 0xff8e, "\x30\xdb" }, + { 0xff8f, "\x30\xde" }, + { 0xff90, "\x30\xdf" }, + { 0xff91, "\x30\xe0" }, + { 0xff92, "\x30\xe1" }, + { 0xff93, "\x30\xe2" }, + { 0xff94, "\x30\xe4" }, + { 0xff95, "\x30\xe6" }, + { 0xff96, "\x30\xe8" }, + { 0xff97, "\x30\xe9" }, + { 0xff98, "\x30\xea" }, + { 0xff99, "\x30\xeb" }, + { 0xff9a, "\x30\xec" }, + { 0xff9b, "\x30\xed" }, + { 0xff9c, "\x30\xef" }, + { 0xff9d, "\x30\xf3" }, + { 0xff9e, "\x30\x99" }, + { 0xff9f, "\x30\x9a" }, + { 0xffa0, "\x31\x64" }, + { 0xffa1, "\x31\x31" }, + { 0xffa2, "\x31\x32" }, + { 0xffa3, "\x31\x33" }, + { 0xffa4, "\x31\x34" }, + { 0xffa5, "\x31\x35" }, + { 0xffa6, "\x31\x36" }, + { 0xffa7, "\x31\x37" }, + { 0xffa8, "\x31\x38" }, + { 0xffa9, "\x31\x39" }, + { 0xffaa, "\x31\x3a" }, + { 0xffab, "\x31\x3b" }, + { 0xffac, "\x31\x3c" }, + { 0xffad, "\x31\x3d" }, + { 0xffae, "\x31\x3e" }, + { 0xffaf, "\x31\x3f" }, + { 0xffb0, "\x31\x40" }, + { 0xffb1, "\x31\x41" }, + { 0xffb2, "\x31\x42" }, + { 0xffb3, "\x31\x43" }, + { 0xffb4, "\x31\x44" }, + { 0xffb5, "\x31\x45" }, + { 0xffb6, "\x31\x46" }, + { 0xffb7, "\x31\x47" }, + { 0xffb8, "\x31\x48" }, + { 0xffb9, "\x31\x49" }, + { 0xffba, "\x31\x4a" }, + { 0xffbb, "\x31\x4b" }, + { 0xffbc, "\x31\x4c" }, + { 0xffbd, "\x31\x4d" }, + { 0xffbe, "\x31\x4e" }, + { 0xffc2, "\x31\x4f" }, + { 0xffc3, "\x31\x50" }, + { 0xffc4, "\x31\x51" }, + { 0xffc5, "\x31\x52" }, + { 0xffc6, "\x31\x53" }, + { 0xffc7, "\x31\x54" }, + { 0xffca, "\x31\x55" }, + { 0xffcb, "\x31\x56" }, + { 0xffcc, "\x31\x57" }, + { 0xffcd, "\x31\x58" }, + { 0xffce, "\x31\x59" }, + { 0xffcf, "\x31\x5a" }, + { 0xffd2, "\x31\x5b" }, + { 0xffd3, "\x31\x5c" }, + { 0xffd4, "\x31\x5d" }, + { 0xffd5, "\x31\x5e" }, + { 0xffd6, "\x31\x5f" }, + { 0xffd7, "\x31\x60" }, + { 0xffda, "\x31\x61" }, + { 0xffdb, "\x31\x62" }, + { 0xffdc, "\x31\x63" }, + { 0xffe0, "\x00\xa2" }, + { 0xffe1, "\x00\xa3" }, + { 0xffe2, "\x00\xac" }, + { 0xffe3, "\x00\xaf" }, + { 0xffe4, "\x00\xa6" }, + { 0xffe5, "\x00\xa5" }, + { 0xffe6, "\x20\xa9" }, + { 0xffe8, "\x25\x02" }, + { 0xffe9, "\x21\x90" }, + { 0xffea, "\x21\x91" }, + { 0xffeb, "\x21\x92" }, + { 0xffec, "\x21\x93" }, + { 0xffed, "\x25\xa0" }, + { 0xffee, "\x25\xcb" } +}; + +#endif /* __JAVA_CHARDECOMP_H__ */ diff --git a/libjava/include/java-chartables.h b/libjava/include/java-chartables.h new file mode 100644 index 00000000000..b1053da61cb --- /dev/null +++ b/libjava/include/java-chartables.h @@ -0,0 +1,82984 @@ +// java-chartables.h - Character tables for java.lang.Character -*- c++ -*- + +#ifndef __JAVA_CHARTABLES_H__ +#define __JAVA_CHARTABLES_H__ + +// These tables are automatically generated by the chartables.pl +// script. DO NOT EDIT the tables. Instead, fix the script +// and run it again. + +// This file should only be included by natCharacter.cc + +static const jchar title_to_lower_table[][2] = + { + { 0x01c5, 0x01c6 }, // LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON + { 0x01c8, 0x01c9 }, // LATIN CAPITAL LETTER L WITH SMALL LETTER J + { 0x01cb, 0x01cc }, // LATIN CAPITAL LETTER N WITH SMALL LETTER J + { 0x01f2, 0x01f3 } // LATIN CAPITAL LETTER D WITH SMALL LETTER Z + }; + +static const jchar title_to_upper_table[][2] = + { + { 0x01c5, 0x01c4 }, // LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON + { 0x01c8, 0x01c7 }, // LATIN CAPITAL LETTER L WITH SMALL LETTER J + { 0x01cb, 0x01ca }, // LATIN CAPITAL LETTER N WITH SMALL LETTER J + { 0x01f2, 0x01f1 } // LATIN CAPITAL LETTER D WITH SMALL LETTER Z + }; + +#ifdef COMPACT_CHARACTER + +#define TAMIL_DIGIT_ONE 0x0be7 + +static const jchar numeric_table[] = + { 0x00b2, 0x00b3, 0x00b9, 0x00bc, 0x00bd, + 0x00be, 0x09f4, 0x09f5, 0x09f6, 0x09f7, + 0x09f8, 0x09f9, 0x0bf0, 0x0bf1, 0x0bf2, + 0x2070, 0x2074, 0x2075, 0x2076, 0x2077, + 0x2078, 0x2079, 0x2080, 0x2081, 0x2082, + 0x2083, 0x2084, 0x2085, 0x2086, 0x2087, + 0x2088, 0x2089, 0x2153, 0x2154, 0x2155, + 0x2156, 0x2157, 0x2158, 0x2159, 0x215a, + 0x215b, 0x215c, 0x215d, 0x215e, 0x215f, + 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, + 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, + 0x216a, 0x216b, 0x216c, 0x216d, 0x216e, + 0x216f, 0x2170, 0x2171, 0x2172, 0x2173, + 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, + 0x2179, 0x217a, 0x217b, 0x217c, 0x217d, + 0x217e, 0x217f, 0x2180, 0x2181, 0x2182, + 0x2460, 0x2461, 0x2462, 0x2463, 0x2464, + 0x2465, 0x2466, 0x2467, 0x2468, 0x2469, + 0x246a, 0x246b, 0x246c, 0x246d, 0x246e, + 0x246f, 0x2470, 0x2471, 0x2472, 0x2473, + 0x2474, 0x2475, 0x2476, 0x2477, 0x2478, + 0x2479, 0x247a, 0x247b, 0x247c, 0x247d, + 0x247e, 0x247f, 0x2480, 0x2481, 0x2482, + 0x2483, 0x2484, 0x2485, 0x2486, 0x2487, + 0x2488, 0x2489, 0x248a, 0x248b, 0x248c, + 0x248d, 0x248e, 0x248f, 0x2490, 0x2491, + 0x2492, 0x2493, 0x2494, 0x2495, 0x2496, + 0x2497, 0x2498, 0x2499, 0x249a, 0x249b, + 0x24ea, 0x2776, 0x2777, 0x2778, 0x2779, + 0x277a, 0x277b, 0x277c, 0x277d, 0x277e, + 0x277f, 0x2780, 0x2781, 0x2782, 0x2783, + 0x2784, 0x2785, 0x2786, 0x2787, 0x2788, + 0x2789, 0x278a, 0x278b, 0x278c, 0x278d, + 0x278e, 0x278f, 0x2790, 0x2791, 0x2792, + 0x2793, 0x3007, 0x3021, 0x3022, 0x3023, + 0x3024, 0x3025, 0x3026, 0x3027, 0x3028, + 0x3029, 0x3280, 0x3281, 0x3282, 0x3283, + 0x3284, 0x3285, 0x3286, 0x3287, 0x3288, + 0x3289 }; + +static const jshort numeric_value[] = + { 2, 3, 1, -2, -2, -2, 1, 2, 3, 4, + -2, 16, 10, 100, 1000, 0, 4, 5, 6, 7, + 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, + 8, 9, -2, -2, -2, -2, -2, -2, -2, -2, + -2, -2, -2, -2, 1, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 50, 100, 500, + 1000, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 50, 100, 500, 1000, 1000, 5000, 10000, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10 }; + +static const jchar digit_table[][2] = + { + { 0x0030, 0x0039 }, + { 0x0660, 0x0669 }, + { 0x06f0, 0x06f9 }, + { 0x0966, 0x096f }, + { 0x09e6, 0x09ef }, + { 0x0a66, 0x0a6f }, + { 0x0ae6, 0x0aef }, + { 0x0b66, 0x0b6f }, + { 0x0be7, 0x0bef }, + { 0x0c66, 0x0c6f }, + { 0x0ce6, 0x0cef }, + { 0x0d66, 0x0d6f }, + { 0x0e50, 0x0e59 }, + { 0x0ed0, 0x0ed9 }, + { 0x0f20, 0x0f29 }, + { 0xff10, 0xff19 } + }; + +static const jchar space_table[][2] = + { + { 0x0020, 0x0020 }, + { 0x00a0, 0x00a0 }, + { 0x2000, 0x200b }, + { 0x2028, 0x2029 }, + { 0x3000, 0x3000 } + }; + +static const jchar upper_case_table[][2] = + { + { 0x0041, 0x005a }, + { 0x00c0, 0x00d6 }, + { 0x00d8, 0x00de }, + { 0x0100, 0x0100 }, + { 0x0102, 0x0102 }, + { 0x0104, 0x0104 }, + { 0x0106, 0x0106 }, + { 0x0108, 0x0108 }, + { 0x010a, 0x010a }, + { 0x010c, 0x010c }, + { 0x010e, 0x010e }, + { 0x0110, 0x0110 }, + { 0x0112, 0x0112 }, + { 0x0114, 0x0114 }, + { 0x0116, 0x0116 }, + { 0x0118, 0x0118 }, + { 0x011a, 0x011a }, + { 0x011c, 0x011c }, + { 0x011e, 0x011e }, + { 0x0120, 0x0120 }, + { 0x0122, 0x0122 }, + { 0x0124, 0x0124 }, + { 0x0126, 0x0126 }, + { 0x0128, 0x0128 }, + { 0x012a, 0x012a }, + { 0x012c, 0x012c }, + { 0x012e, 0x012e }, + { 0x0130, 0x0130 }, + { 0x0132, 0x0132 }, + { 0x0134, 0x0134 }, + { 0x0136, 0x0136 }, + { 0x0139, 0x0139 }, + { 0x013b, 0x013b }, + { 0x013d, 0x013d }, + { 0x013f, 0x013f }, + { 0x0141, 0x0141 }, + { 0x0143, 0x0143 }, + { 0x0145, 0x0145 }, + { 0x0147, 0x0147 }, + { 0x014a, 0x014a }, + { 0x014c, 0x014c }, + { 0x014e, 0x014e }, + { 0x0150, 0x0150 }, + { 0x0152, 0x0152 }, + { 0x0154, 0x0154 }, + { 0x0156, 0x0156 }, + { 0x0158, 0x0158 }, + { 0x015a, 0x015a }, + { 0x015c, 0x015c }, + { 0x015e, 0x015e }, + { 0x0160, 0x0160 }, + { 0x0162, 0x0162 }, + { 0x0164, 0x0164 }, + { 0x0166, 0x0166 }, + { 0x0168, 0x0168 }, + { 0x016a, 0x016a }, + { 0x016c, 0x016c }, + { 0x016e, 0x016e }, + { 0x0170, 0x0170 }, + { 0x0172, 0x0172 }, + { 0x0174, 0x0174 }, + { 0x0176, 0x0176 }, + { 0x0178, 0x0178 }, + { 0x0179, 0x0179 }, + { 0x017b, 0x017b }, + { 0x017d, 0x017d }, + { 0x0181, 0x0181 }, + { 0x0182, 0x0182 }, + { 0x0184, 0x0184 }, + { 0x0186, 0x0186 }, + { 0x0187, 0x0187 }, + { 0x0189, 0x018a }, + { 0x018b, 0x018b }, + { 0x018e, 0x018e }, + { 0x018f, 0x018f }, + { 0x0190, 0x0190 }, + { 0x0191, 0x0191 }, + { 0x0193, 0x0193 }, + { 0x0194, 0x0194 }, + { 0x0196, 0x0196 }, + { 0x0197, 0x0197 }, + { 0x0198, 0x0198 }, + { 0x019c, 0x019c }, + { 0x019d, 0x019d }, + { 0x019f, 0x019f }, + { 0x01a0, 0x01a0 }, + { 0x01a2, 0x01a2 }, + { 0x01a4, 0x01a4 }, + { 0x01a6, 0x01a6 }, + { 0x01a7, 0x01a7 }, + { 0x01a9, 0x01a9 }, + { 0x01ac, 0x01ac }, + { 0x01ae, 0x01ae }, + { 0x01af, 0x01af }, + { 0x01b1, 0x01b2 }, + { 0x01b3, 0x01b3 }, + { 0x01b5, 0x01b5 }, + { 0x01b7, 0x01b7 }, + { 0x01b8, 0x01b8 }, + { 0x01bc, 0x01bc }, + { 0x01c4, 0x01c4 }, + { 0x01c7, 0x01c7 }, + { 0x01ca, 0x01ca }, + { 0x01cd, 0x01cd }, + { 0x01cf, 0x01cf }, + { 0x01d1, 0x01d1 }, + { 0x01d3, 0x01d3 }, + { 0x01d5, 0x01d5 }, + { 0x01d7, 0x01d7 }, + { 0x01d9, 0x01d9 }, + { 0x01db, 0x01db }, + { 0x01de, 0x01de }, + { 0x01e0, 0x01e0 }, + { 0x01e2, 0x01e2 }, + { 0x01e4, 0x01e4 }, + { 0x01e6, 0x01e6 }, + { 0x01e8, 0x01e8 }, + { 0x01ea, 0x01ea }, + { 0x01ec, 0x01ec }, + { 0x01ee, 0x01ee }, + { 0x01f1, 0x01f1 }, + { 0x01f4, 0x01f4 }, + { 0x01fa, 0x01fa }, + { 0x01fc, 0x01fc }, + { 0x01fe, 0x01fe }, + { 0x0200, 0x0200 }, + { 0x0202, 0x0202 }, + { 0x0204, 0x0204 }, + { 0x0206, 0x0206 }, + { 0x0208, 0x0208 }, + { 0x020a, 0x020a }, + { 0x020c, 0x020c }, + { 0x020e, 0x020e }, + { 0x0210, 0x0210 }, + { 0x0212, 0x0212 }, + { 0x0214, 0x0214 }, + { 0x0216, 0x0216 }, + { 0x0386, 0x0386 }, + { 0x0388, 0x038a }, + { 0x038c, 0x038c }, + { 0x038e, 0x038f }, + { 0x0391, 0x03a1 }, + { 0x03a3, 0x03ab }, + { 0x03e2, 0x03e2 }, + { 0x03e4, 0x03e4 }, + { 0x03e6, 0x03e6 }, + { 0x03e8, 0x03e8 }, + { 0x03ea, 0x03ea }, + { 0x03ec, 0x03ec }, + { 0x03ee, 0x03ee }, + { 0x0401, 0x040c }, + { 0x040e, 0x040f }, + { 0x0410, 0x042f }, + { 0x0460, 0x0460 }, + { 0x0462, 0x0462 }, + { 0x0464, 0x0464 }, + { 0x0466, 0x0466 }, + { 0x0468, 0x0468 }, + { 0x046a, 0x046a }, + { 0x046c, 0x046c }, + { 0x046e, 0x046e }, + { 0x0470, 0x0470 }, + { 0x0472, 0x0472 }, + { 0x0474, 0x0474 }, + { 0x0476, 0x0476 }, + { 0x0478, 0x0478 }, + { 0x047a, 0x047a }, + { 0x047c, 0x047c }, + { 0x047e, 0x047e }, + { 0x0480, 0x0480 }, + { 0x0490, 0x0490 }, + { 0x0492, 0x0492 }, + { 0x0494, 0x0494 }, + { 0x0496, 0x0496 }, + { 0x0498, 0x0498 }, + { 0x049a, 0x049a }, + { 0x049c, 0x049c }, + { 0x049e, 0x049e }, + { 0x04a0, 0x04a0 }, + { 0x04a2, 0x04a2 }, + { 0x04a4, 0x04a4 }, + { 0x04a6, 0x04a6 }, + { 0x04a8, 0x04a8 }, + { 0x04aa, 0x04aa }, + { 0x04ac, 0x04ac }, + { 0x04ae, 0x04ae }, + { 0x04b0, 0x04b0 }, + { 0x04b2, 0x04b2 }, + { 0x04b4, 0x04b4 }, + { 0x04b6, 0x04b6 }, + { 0x04b8, 0x04b8 }, + { 0x04ba, 0x04ba }, + { 0x04bc, 0x04bc }, + { 0x04be, 0x04be }, + { 0x04c1, 0x04c1 }, + { 0x04c3, 0x04c3 }, + { 0x04c7, 0x04c7 }, + { 0x04cb, 0x04cb }, + { 0x04d0, 0x04d0 }, + { 0x04d2, 0x04d2 }, + { 0x04d4, 0x04d4 }, + { 0x04d6, 0x04d6 }, + { 0x04d8, 0x04d8 }, + { 0x04da, 0x04da }, + { 0x04dc, 0x04dc }, + { 0x04de, 0x04de }, + { 0x04e0, 0x04e0 }, + { 0x04e2, 0x04e2 }, + { 0x04e4, 0x04e4 }, + { 0x04e6, 0x04e6 }, + { 0x04e8, 0x04e8 }, + { 0x04ea, 0x04ea }, + { 0x04ee, 0x04ee }, + { 0x04f0, 0x04f0 }, + { 0x04f2, 0x04f2 }, + { 0x04f4, 0x04f4 }, + { 0x04f8, 0x04f8 }, + { 0x0531, 0x0556 }, + { 0x10a0, 0x10c5 }, + { 0x1e00, 0x1e00 }, + { 0x1e02, 0x1e02 }, + { 0x1e04, 0x1e04 }, + { 0x1e06, 0x1e06 }, + { 0x1e08, 0x1e08 }, + { 0x1e0a, 0x1e0a }, + { 0x1e0c, 0x1e0c }, + { 0x1e0e, 0x1e0e }, + { 0x1e10, 0x1e10 }, + { 0x1e12, 0x1e12 }, + { 0x1e14, 0x1e14 }, + { 0x1e16, 0x1e16 }, + { 0x1e18, 0x1e18 }, + { 0x1e1a, 0x1e1a }, + { 0x1e1c, 0x1e1c }, + { 0x1e1e, 0x1e1e }, + { 0x1e20, 0x1e20 }, + { 0x1e22, 0x1e22 }, + { 0x1e24, 0x1e24 }, + { 0x1e26, 0x1e26 }, + { 0x1e28, 0x1e28 }, + { 0x1e2a, 0x1e2a }, + { 0x1e2c, 0x1e2c }, + { 0x1e2e, 0x1e2e }, + { 0x1e30, 0x1e30 }, + { 0x1e32, 0x1e32 }, + { 0x1e34, 0x1e34 }, + { 0x1e36, 0x1e36 }, + { 0x1e38, 0x1e38 }, + { 0x1e3a, 0x1e3a }, + { 0x1e3c, 0x1e3c }, + { 0x1e3e, 0x1e3e }, + { 0x1e40, 0x1e40 }, + { 0x1e42, 0x1e42 }, + { 0x1e44, 0x1e44 }, + { 0x1e46, 0x1e46 }, + { 0x1e48, 0x1e48 }, + { 0x1e4a, 0x1e4a }, + { 0x1e4c, 0x1e4c }, + { 0x1e4e, 0x1e4e }, + { 0x1e50, 0x1e50 }, + { 0x1e52, 0x1e52 }, + { 0x1e54, 0x1e54 }, + { 0x1e56, 0x1e56 }, + { 0x1e58, 0x1e58 }, + { 0x1e5a, 0x1e5a }, + { 0x1e5c, 0x1e5c }, + { 0x1e5e, 0x1e5e }, + { 0x1e60, 0x1e60 }, + { 0x1e62, 0x1e62 }, + { 0x1e64, 0x1e64 }, + { 0x1e66, 0x1e66 }, + { 0x1e68, 0x1e68 }, + { 0x1e6a, 0x1e6a }, + { 0x1e6c, 0x1e6c }, + { 0x1e6e, 0x1e6e }, + { 0x1e70, 0x1e70 }, + { 0x1e72, 0x1e72 }, + { 0x1e74, 0x1e74 }, + { 0x1e76, 0x1e76 }, + { 0x1e78, 0x1e78 }, + { 0x1e7a, 0x1e7a }, + { 0x1e7c, 0x1e7c }, + { 0x1e7e, 0x1e7e }, + { 0x1e80, 0x1e80 }, + { 0x1e82, 0x1e82 }, + { 0x1e84, 0x1e84 }, + { 0x1e86, 0x1e86 }, + { 0x1e88, 0x1e88 }, + { 0x1e8a, 0x1e8a }, + { 0x1e8c, 0x1e8c }, + { 0x1e8e, 0x1e8e }, + { 0x1e90, 0x1e90 }, + { 0x1e92, 0x1e92 }, + { 0x1e94, 0x1e94 }, + { 0x1ea0, 0x1ea0 }, + { 0x1ea2, 0x1ea2 }, + { 0x1ea4, 0x1ea4 }, + { 0x1ea6, 0x1ea6 }, + { 0x1ea8, 0x1ea8 }, + { 0x1eaa, 0x1eaa }, + { 0x1eac, 0x1eac }, + { 0x1eae, 0x1eae }, + { 0x1eb0, 0x1eb0 }, + { 0x1eb2, 0x1eb2 }, + { 0x1eb4, 0x1eb4 }, + { 0x1eb6, 0x1eb6 }, + { 0x1eb8, 0x1eb8 }, + { 0x1eba, 0x1eba }, + { 0x1ebc, 0x1ebc }, + { 0x1ebe, 0x1ebe }, + { 0x1ec0, 0x1ec0 }, + { 0x1ec2, 0x1ec2 }, + { 0x1ec4, 0x1ec4 }, + { 0x1ec6, 0x1ec6 }, + { 0x1ec8, 0x1ec8 }, + { 0x1eca, 0x1eca }, + { 0x1ecc, 0x1ecc }, + { 0x1ece, 0x1ece }, + { 0x1ed0, 0x1ed0 }, + { 0x1ed2, 0x1ed2 }, + { 0x1ed4, 0x1ed4 }, + { 0x1ed6, 0x1ed6 }, + { 0x1ed8, 0x1ed8 }, + { 0x1eda, 0x1eda }, + { 0x1edc, 0x1edc }, + { 0x1ede, 0x1ede }, + { 0x1ee0, 0x1ee0 }, + { 0x1ee2, 0x1ee2 }, + { 0x1ee4, 0x1ee4 }, + { 0x1ee6, 0x1ee6 }, + { 0x1ee8, 0x1ee8 }, + { 0x1eea, 0x1eea }, + { 0x1eec, 0x1eec }, + { 0x1eee, 0x1eee }, + { 0x1ef0, 0x1ef0 }, + { 0x1ef2, 0x1ef2 }, + { 0x1ef4, 0x1ef4 }, + { 0x1ef6, 0x1ef6 }, + { 0x1ef8, 0x1ef8 }, + { 0x1f08, 0x1f0f }, + { 0x1f18, 0x1f1d }, + { 0x1f28, 0x1f2f }, + { 0x1f38, 0x1f3f }, + { 0x1f48, 0x1f4d }, + { 0x1f59, 0x1f59 }, + { 0x1f5b, 0x1f5b }, + { 0x1f5d, 0x1f5d }, + { 0x1f5f, 0x1f5f }, + { 0x1f68, 0x1f6f }, + { 0x1f88, 0x1f8f }, + { 0x1f98, 0x1f9f }, + { 0x1fa8, 0x1faf }, + { 0x1fb8, 0x1fb9 }, + { 0x1fba, 0x1fbb }, + { 0x1fbc, 0x1fbc }, + { 0x1fc8, 0x1fcb }, + { 0x1fcc, 0x1fcc }, + { 0x1fd8, 0x1fd9 }, + { 0x1fda, 0x1fdb }, + { 0x1fe8, 0x1fe9 }, + { 0x1fea, 0x1feb }, + { 0x1fec, 0x1fec }, + { 0x1ff8, 0x1ff9 }, + { 0x1ffa, 0x1ffb }, + { 0x1ffc, 0x1ffc }, + { 0x2160, 0x216f }, + { 0x24b6, 0x24cf }, + { 0xff21, 0xff3a } + }; + +static const jchar upper_case_map_table[] = + { 0x0061, 0x00e0, 0x00f8, 0x0101, 0x0103, + 0x0105, 0x0107, 0x0109, 0x010b, 0x010d, + 0x010f, 0x0111, 0x0113, 0x0115, 0x0117, + 0x0119, 0x011b, 0x011d, 0x011f, 0x0121, + 0x0123, 0x0125, 0x0127, 0x0129, 0x012b, + 0x012d, 0x012f, 0x0069, 0x0133, 0x0135, + 0x0137, 0x013a, 0x013c, 0x013e, 0x0140, + 0x0142, 0x0144, 0x0146, 0x0148, 0x014b, + 0x014d, 0x014f, 0x0151, 0x0153, 0x0155, + 0x0157, 0x0159, 0x015b, 0x015d, 0x015f, + 0x0161, 0x0163, 0x0165, 0x0167, 0x0169, + 0x016b, 0x016d, 0x016f, 0x0171, 0x0173, + 0x0175, 0x0177, 0x00ff, 0x017a, 0x017c, + 0x017e, 0x0253, 0x0183, 0x0185, 0x0254, + 0x0188, 0x0256, 0x018c, 0x01dd, 0x0259, + 0x025b, 0x0192, 0x0260, 0x0263, 0x0269, + 0x0268, 0x0199, 0x026f, 0x0272, 0x0275, + 0x01a1, 0x01a3, 0x01a5, 0x0280, 0x01a8, + 0x0283, 0x01ad, 0x0288, 0x01b0, 0x028a, + 0x01b4, 0x01b6, 0x0292, 0x01b9, 0x01bd, + 0x01c6, 0x01c9, 0x01cc, 0x01ce, 0x01d0, + 0x01d2, 0x01d4, 0x01d6, 0x01d8, 0x01da, + 0x01dc, 0x01df, 0x01e1, 0x01e3, 0x01e5, + 0x01e7, 0x01e9, 0x01eb, 0x01ed, 0x01ef, + 0x01f3, 0x01f5, 0x01fb, 0x01fd, 0x01ff, + 0x0201, 0x0203, 0x0205, 0x0207, 0x0209, + 0x020b, 0x020d, 0x020f, 0x0211, 0x0213, + 0x0215, 0x0217, 0x03ac, 0x03ad, 0x03cc, + 0x03cd, 0x03b1, 0x03c3, 0x03e3, 0x03e5, + 0x03e7, 0x03e9, 0x03eb, 0x03ed, 0x03ef, + 0x0451, 0x045e, 0x0430, 0x0461, 0x0463, + 0x0465, 0x0467, 0x0469, 0x046b, 0x046d, + 0x046f, 0x0471, 0x0473, 0x0475, 0x0477, + 0x0479, 0x047b, 0x047d, 0x047f, 0x0481, + 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, + 0x049b, 0x049d, 0x049f, 0x04a1, 0x04a3, + 0x04a5, 0x04a7, 0x04a9, 0x04ab, 0x04ad, + 0x04af, 0x04b1, 0x04b3, 0x04b5, 0x04b7, + 0x04b9, 0x04bb, 0x04bd, 0x04bf, 0x04c2, + 0x04c4, 0x04c8, 0x04cc, 0x04d1, 0x04d3, + 0x04d5, 0x04d7, 0x04d9, 0x04db, 0x04dd, + 0x04df, 0x04e1, 0x04e3, 0x04e5, 0x04e7, + 0x04e9, 0x04eb, 0x04ef, 0x04f1, 0x04f3, + 0x04f5, 0x04f9, 0x0561, 0x10d0, 0x1e01, + 0x1e03, 0x1e05, 0x1e07, 0x1e09, 0x1e0b, + 0x1e0d, 0x1e0f, 0x1e11, 0x1e13, 0x1e15, + 0x1e17, 0x1e19, 0x1e1b, 0x1e1d, 0x1e1f, + 0x1e21, 0x1e23, 0x1e25, 0x1e27, 0x1e29, + 0x1e2b, 0x1e2d, 0x1e2f, 0x1e31, 0x1e33, + 0x1e35, 0x1e37, 0x1e39, 0x1e3b, 0x1e3d, + 0x1e3f, 0x1e41, 0x1e43, 0x1e45, 0x1e47, + 0x1e49, 0x1e4b, 0x1e4d, 0x1e4f, 0x1e51, + 0x1e53, 0x1e55, 0x1e57, 0x1e59, 0x1e5b, + 0x1e5d, 0x1e5f, 0x1e61, 0x1e63, 0x1e65, + 0x1e67, 0x1e69, 0x1e6b, 0x1e6d, 0x1e6f, + 0x1e71, 0x1e73, 0x1e75, 0x1e77, 0x1e79, + 0x1e7b, 0x1e7d, 0x1e7f, 0x1e81, 0x1e83, + 0x1e85, 0x1e87, 0x1e89, 0x1e8b, 0x1e8d, + 0x1e8f, 0x1e91, 0x1e93, 0x1e95, 0x1ea1, + 0x1ea3, 0x1ea5, 0x1ea7, 0x1ea9, 0x1eab, + 0x1ead, 0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, + 0x1eb7, 0x1eb9, 0x1ebb, 0x1ebd, 0x1ebf, + 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7, 0x1ec9, + 0x1ecb, 0x1ecd, 0x1ecf, 0x1ed1, 0x1ed3, + 0x1ed5, 0x1ed7, 0x1ed9, 0x1edb, 0x1edd, + 0x1edf, 0x1ee1, 0x1ee3, 0x1ee5, 0x1ee7, + 0x1ee9, 0x1eeb, 0x1eed, 0x1eef, 0x1ef1, + 0x1ef3, 0x1ef5, 0x1ef7, 0x1ef9, 0x1f00, + 0x1f10, 0x1f20, 0x1f30, 0x1f40, 0x1f51, + 0x1f53, 0x1f55, 0x1f57, 0x1f60, 0x1f80, + 0x1f90, 0x1fa0, 0x1fb0, 0x1f70, 0x1fb3, + 0x1f72, 0x1fc3, 0x1fd0, 0x1f76, 0x1fe0, + 0x1f7a, 0x1fe5, 0x1f78, 0x1f7c, 0x1ff3, + 0x2170, 0x24d0, 0xff41 }; + +static const jchar lower_case_table[][2] = + { + { 0x0061, 0x007a }, + { 0x00e0, 0x00f6 }, + { 0x00f8, 0x00fe }, + { 0x00ff, 0x00ff }, + { 0x0101, 0x0101 }, + { 0x0103, 0x0103 }, + { 0x0105, 0x0105 }, + { 0x0107, 0x0107 }, + { 0x0109, 0x0109 }, + { 0x010b, 0x010b }, + { 0x010d, 0x010d }, + { 0x010f, 0x010f }, + { 0x0111, 0x0111 }, + { 0x0113, 0x0113 }, + { 0x0115, 0x0115 }, + { 0x0117, 0x0117 }, + { 0x0119, 0x0119 }, + { 0x011b, 0x011b }, + { 0x011d, 0x011d }, + { 0x011f, 0x011f }, + { 0x0121, 0x0121 }, + { 0x0123, 0x0123 }, + { 0x0125, 0x0125 }, + { 0x0127, 0x0127 }, + { 0x0129, 0x0129 }, + { 0x012b, 0x012b }, + { 0x012d, 0x012d }, + { 0x012f, 0x012f }, + { 0x0131, 0x0131 }, + { 0x0133, 0x0133 }, + { 0x0135, 0x0135 }, + { 0x0137, 0x0137 }, + { 0x013a, 0x013a }, + { 0x013c, 0x013c }, + { 0x013e, 0x013e }, + { 0x0140, 0x0140 }, + { 0x0142, 0x0142 }, + { 0x0144, 0x0144 }, + { 0x0146, 0x0146 }, + { 0x0148, 0x0148 }, + { 0x014b, 0x014b }, + { 0x014d, 0x014d }, + { 0x014f, 0x014f }, + { 0x0151, 0x0151 }, + { 0x0153, 0x0153 }, + { 0x0155, 0x0155 }, + { 0x0157, 0x0157 }, + { 0x0159, 0x0159 }, + { 0x015b, 0x015b }, + { 0x015d, 0x015d }, + { 0x015f, 0x015f }, + { 0x0161, 0x0161 }, + { 0x0163, 0x0163 }, + { 0x0165, 0x0165 }, + { 0x0167, 0x0167 }, + { 0x0169, 0x0169 }, + { 0x016b, 0x016b }, + { 0x016d, 0x016d }, + { 0x016f, 0x016f }, + { 0x0171, 0x0171 }, + { 0x0173, 0x0173 }, + { 0x0175, 0x0175 }, + { 0x0177, 0x0177 }, + { 0x017a, 0x017a }, + { 0x017c, 0x017c }, + { 0x017e, 0x017e }, + { 0x017f, 0x017f }, + { 0x0183, 0x0183 }, + { 0x0185, 0x0185 }, + { 0x0188, 0x0188 }, + { 0x018c, 0x018c }, + { 0x0192, 0x0192 }, + { 0x0199, 0x0199 }, + { 0x01a1, 0x01a1 }, + { 0x01a3, 0x01a3 }, + { 0x01a5, 0x01a5 }, + { 0x01a8, 0x01a8 }, + { 0x01ad, 0x01ad }, + { 0x01b0, 0x01b0 }, + { 0x01b4, 0x01b4 }, + { 0x01b6, 0x01b6 }, + { 0x01b9, 0x01b9 }, + { 0x01bd, 0x01bd }, + { 0x01c6, 0x01c6 }, + { 0x01c9, 0x01c9 }, + { 0x01cc, 0x01cc }, + { 0x01ce, 0x01ce }, + { 0x01d0, 0x01d0 }, + { 0x01d2, 0x01d2 }, + { 0x01d4, 0x01d4 }, + { 0x01d6, 0x01d6 }, + { 0x01d8, 0x01d8 }, + { 0x01da, 0x01da }, + { 0x01dc, 0x01dc }, + { 0x01dd, 0x01dd }, + { 0x01df, 0x01df }, + { 0x01e1, 0x01e1 }, + { 0x01e3, 0x01e3 }, + { 0x01e5, 0x01e5 }, + { 0x01e7, 0x01e7 }, + { 0x01e9, 0x01e9 }, + { 0x01eb, 0x01eb }, + { 0x01ed, 0x01ed }, + { 0x01ef, 0x01ef }, + { 0x01f3, 0x01f3 }, + { 0x01f5, 0x01f5 }, + { 0x01fb, 0x01fb }, + { 0x01fd, 0x01fd }, + { 0x01ff, 0x01ff }, + { 0x0201, 0x0201 }, + { 0x0203, 0x0203 }, + { 0x0205, 0x0205 }, + { 0x0207, 0x0207 }, + { 0x0209, 0x0209 }, + { 0x020b, 0x020b }, + { 0x020d, 0x020d }, + { 0x020f, 0x020f }, + { 0x0211, 0x0211 }, + { 0x0213, 0x0213 }, + { 0x0215, 0x0215 }, + { 0x0217, 0x0217 }, + { 0x0253, 0x0253 }, + { 0x0254, 0x0254 }, + { 0x0256, 0x0257 }, + { 0x0259, 0x0259 }, + { 0x025b, 0x025b }, + { 0x0260, 0x0260 }, + { 0x0263, 0x0263 }, + { 0x0268, 0x0268 }, + { 0x0269, 0x0269 }, + { 0x026f, 0x026f }, + { 0x0272, 0x0272 }, + { 0x0275, 0x0275 }, + { 0x0280, 0x0280 }, + { 0x0283, 0x0283 }, + { 0x0288, 0x0288 }, + { 0x028a, 0x028b }, + { 0x0292, 0x0292 }, + { 0x0345, 0x0345 }, + { 0x03ac, 0x03ac }, + { 0x03ad, 0x03af }, + { 0x03b1, 0x03c1 }, + { 0x03c2, 0x03c2 }, + { 0x03c3, 0x03cb }, + { 0x03cc, 0x03cc }, + { 0x03cd, 0x03ce }, + { 0x03d0, 0x03d0 }, + { 0x03d1, 0x03d1 }, + { 0x03d5, 0x03d5 }, + { 0x03d6, 0x03d6 }, + { 0x03e3, 0x03e3 }, + { 0x03e5, 0x03e5 }, + { 0x03e7, 0x03e7 }, + { 0x03e9, 0x03e9 }, + { 0x03eb, 0x03eb }, + { 0x03ed, 0x03ed }, + { 0x03ef, 0x03ef }, + { 0x03f0, 0x03f0 }, + { 0x03f1, 0x03f1 }, + { 0x03f2, 0x03f2 }, + { 0x0430, 0x044f }, + { 0x0451, 0x045c }, + { 0x045e, 0x045f }, + { 0x0461, 0x0461 }, + { 0x0463, 0x0463 }, + { 0x0465, 0x0465 }, + { 0x0467, 0x0467 }, + { 0x0469, 0x0469 }, + { 0x046b, 0x046b }, + { 0x046d, 0x046d }, + { 0x046f, 0x046f }, + { 0x0471, 0x0471 }, + { 0x0473, 0x0473 }, + { 0x0475, 0x0475 }, + { 0x0477, 0x0477 }, + { 0x0479, 0x0479 }, + { 0x047b, 0x047b }, + { 0x047d, 0x047d }, + { 0x047f, 0x047f }, + { 0x0481, 0x0481 }, + { 0x0491, 0x0491 }, + { 0x0493, 0x0493 }, + { 0x0495, 0x0495 }, + { 0x0497, 0x0497 }, + { 0x0499, 0x0499 }, + { 0x049b, 0x049b }, + { 0x049d, 0x049d }, + { 0x049f, 0x049f }, + { 0x04a1, 0x04a1 }, + { 0x04a3, 0x04a3 }, + { 0x04a5, 0x04a5 }, + { 0x04a7, 0x04a7 }, + { 0x04a9, 0x04a9 }, + { 0x04ab, 0x04ab }, + { 0x04ad, 0x04ad }, + { 0x04af, 0x04af }, + { 0x04b1, 0x04b1 }, + { 0x04b3, 0x04b3 }, + { 0x04b5, 0x04b5 }, + { 0x04b7, 0x04b7 }, + { 0x04b9, 0x04b9 }, + { 0x04bb, 0x04bb }, + { 0x04bd, 0x04bd }, + { 0x04bf, 0x04bf }, + { 0x04c2, 0x04c2 }, + { 0x04c4, 0x04c4 }, + { 0x04c8, 0x04c8 }, + { 0x04cc, 0x04cc }, + { 0x04d1, 0x04d1 }, + { 0x04d3, 0x04d3 }, + { 0x04d5, 0x04d5 }, + { 0x04d7, 0x04d7 }, + { 0x04d9, 0x04d9 }, + { 0x04db, 0x04db }, + { 0x04dd, 0x04dd }, + { 0x04df, 0x04df }, + { 0x04e1, 0x04e1 }, + { 0x04e3, 0x04e3 }, + { 0x04e5, 0x04e5 }, + { 0x04e7, 0x04e7 }, + { 0x04e9, 0x04e9 }, + { 0x04eb, 0x04eb }, + { 0x04ef, 0x04ef }, + { 0x04f1, 0x04f1 }, + { 0x04f3, 0x04f3 }, + { 0x04f5, 0x04f5 }, + { 0x04f9, 0x04f9 }, + { 0x0561, 0x0586 }, + { 0x1e01, 0x1e01 }, + { 0x1e03, 0x1e03 }, + { 0x1e05, 0x1e05 }, + { 0x1e07, 0x1e07 }, + { 0x1e09, 0x1e09 }, + { 0x1e0b, 0x1e0b }, + { 0x1e0d, 0x1e0d }, + { 0x1e0f, 0x1e0f }, + { 0x1e11, 0x1e11 }, + { 0x1e13, 0x1e13 }, + { 0x1e15, 0x1e15 }, + { 0x1e17, 0x1e17 }, + { 0x1e19, 0x1e19 }, + { 0x1e1b, 0x1e1b }, + { 0x1e1d, 0x1e1d }, + { 0x1e1f, 0x1e1f }, + { 0x1e21, 0x1e21 }, + { 0x1e23, 0x1e23 }, + { 0x1e25, 0x1e25 }, + { 0x1e27, 0x1e27 }, + { 0x1e29, 0x1e29 }, + { 0x1e2b, 0x1e2b }, + { 0x1e2d, 0x1e2d }, + { 0x1e2f, 0x1e2f }, + { 0x1e31, 0x1e31 }, + { 0x1e33, 0x1e33 }, + { 0x1e35, 0x1e35 }, + { 0x1e37, 0x1e37 }, + { 0x1e39, 0x1e39 }, + { 0x1e3b, 0x1e3b }, + { 0x1e3d, 0x1e3d }, + { 0x1e3f, 0x1e3f }, + { 0x1e41, 0x1e41 }, + { 0x1e43, 0x1e43 }, + { 0x1e45, 0x1e45 }, + { 0x1e47, 0x1e47 }, + { 0x1e49, 0x1e49 }, + { 0x1e4b, 0x1e4b }, + { 0x1e4d, 0x1e4d }, + { 0x1e4f, 0x1e4f }, + { 0x1e51, 0x1e51 }, + { 0x1e53, 0x1e53 }, + { 0x1e55, 0x1e55 }, + { 0x1e57, 0x1e57 }, + { 0x1e59, 0x1e59 }, + { 0x1e5b, 0x1e5b }, + { 0x1e5d, 0x1e5d }, + { 0x1e5f, 0x1e5f }, + { 0x1e61, 0x1e61 }, + { 0x1e63, 0x1e63 }, + { 0x1e65, 0x1e65 }, + { 0x1e67, 0x1e67 }, + { 0x1e69, 0x1e69 }, + { 0x1e6b, 0x1e6b }, + { 0x1e6d, 0x1e6d }, + { 0x1e6f, 0x1e6f }, + { 0x1e71, 0x1e71 }, + { 0x1e73, 0x1e73 }, + { 0x1e75, 0x1e75 }, + { 0x1e77, 0x1e77 }, + { 0x1e79, 0x1e79 }, + { 0x1e7b, 0x1e7b }, + { 0x1e7d, 0x1e7d }, + { 0x1e7f, 0x1e7f }, + { 0x1e81, 0x1e81 }, + { 0x1e83, 0x1e83 }, + { 0x1e85, 0x1e85 }, + { 0x1e87, 0x1e87 }, + { 0x1e89, 0x1e89 }, + { 0x1e8b, 0x1e8b }, + { 0x1e8d, 0x1e8d }, + { 0x1e8f, 0x1e8f }, + { 0x1e91, 0x1e91 }, + { 0x1e93, 0x1e93 }, + { 0x1e95, 0x1e95 }, + { 0x1e9b, 0x1e9b }, + { 0x1ea1, 0x1ea1 }, + { 0x1ea3, 0x1ea3 }, + { 0x1ea5, 0x1ea5 }, + { 0x1ea7, 0x1ea7 }, + { 0x1ea9, 0x1ea9 }, + { 0x1eab, 0x1eab }, + { 0x1ead, 0x1ead }, + { 0x1eaf, 0x1eaf }, + { 0x1eb1, 0x1eb1 }, + { 0x1eb3, 0x1eb3 }, + { 0x1eb5, 0x1eb5 }, + { 0x1eb7, 0x1eb7 }, + { 0x1eb9, 0x1eb9 }, + { 0x1ebb, 0x1ebb }, + { 0x1ebd, 0x1ebd }, + { 0x1ebf, 0x1ebf }, + { 0x1ec1, 0x1ec1 }, + { 0x1ec3, 0x1ec3 }, + { 0x1ec5, 0x1ec5 }, + { 0x1ec7, 0x1ec7 }, + { 0x1ec9, 0x1ec9 }, + { 0x1ecb, 0x1ecb }, + { 0x1ecd, 0x1ecd }, + { 0x1ecf, 0x1ecf }, + { 0x1ed1, 0x1ed1 }, + { 0x1ed3, 0x1ed3 }, + { 0x1ed5, 0x1ed5 }, + { 0x1ed7, 0x1ed7 }, + { 0x1ed9, 0x1ed9 }, + { 0x1edb, 0x1edb }, + { 0x1edd, 0x1edd }, + { 0x1edf, 0x1edf }, + { 0x1ee1, 0x1ee1 }, + { 0x1ee3, 0x1ee3 }, + { 0x1ee5, 0x1ee5 }, + { 0x1ee7, 0x1ee7 }, + { 0x1ee9, 0x1ee9 }, + { 0x1eeb, 0x1eeb }, + { 0x1eed, 0x1eed }, + { 0x1eef, 0x1eef }, + { 0x1ef1, 0x1ef1 }, + { 0x1ef3, 0x1ef3 }, + { 0x1ef5, 0x1ef5 }, + { 0x1ef7, 0x1ef7 }, + { 0x1ef9, 0x1ef9 }, + { 0x1f00, 0x1f07 }, + { 0x1f10, 0x1f15 }, + { 0x1f20, 0x1f27 }, + { 0x1f30, 0x1f37 }, + { 0x1f40, 0x1f45 }, + { 0x1f51, 0x1f51 }, + { 0x1f53, 0x1f53 }, + { 0x1f55, 0x1f55 }, + { 0x1f57, 0x1f57 }, + { 0x1f60, 0x1f67 }, + { 0x1f70, 0x1f71 }, + { 0x1f72, 0x1f75 }, + { 0x1f76, 0x1f77 }, + { 0x1f78, 0x1f79 }, + { 0x1f7a, 0x1f7b }, + { 0x1f7c, 0x1f7d }, + { 0x1f80, 0x1f87 }, + { 0x1f90, 0x1f97 }, + { 0x1fa0, 0x1fa7 }, + { 0x1fb0, 0x1fb1 }, + { 0x1fb3, 0x1fb3 }, + { 0x1fbe, 0x1fbe }, + { 0x1fc3, 0x1fc3 }, + { 0x1fd0, 0x1fd1 }, + { 0x1fe0, 0x1fe1 }, + { 0x1fe5, 0x1fe5 }, + { 0x1ff3, 0x1ff3 }, + { 0x2170, 0x217f }, + { 0x24d0, 0x24e9 }, + { 0xff41, 0xff5a } + }; + +static const jchar lower_case_map_table[] = + { 0x0041, 0x00c0, 0x00d8, 0x0178, 0x0100, + 0x0102, 0x0104, 0x0106, 0x0108, 0x010a, + 0x010c, 0x010e, 0x0110, 0x0112, 0x0114, + 0x0116, 0x0118, 0x011a, 0x011c, 0x011e, + 0x0120, 0x0122, 0x0124, 0x0126, 0x0128, + 0x012a, 0x012c, 0x012e, 0x0049, 0x0132, + 0x0134, 0x0136, 0x0139, 0x013b, 0x013d, + 0x013f, 0x0141, 0x0143, 0x0145, 0x0147, + 0x014a, 0x014c, 0x014e, 0x0150, 0x0152, + 0x0154, 0x0156, 0x0158, 0x015a, 0x015c, + 0x015e, 0x0160, 0x0162, 0x0164, 0x0166, + 0x0168, 0x016a, 0x016c, 0x016e, 0x0170, + 0x0172, 0x0174, 0x0176, 0x0179, 0x017b, + 0x017d, 0x0053, 0x0182, 0x0184, 0x0187, + 0x018b, 0x0191, 0x0198, 0x01a0, 0x01a2, + 0x01a4, 0x01a7, 0x01ac, 0x01af, 0x01b3, + 0x01b5, 0x01b8, 0x01bc, 0x01c4, 0x01c7, + 0x01ca, 0x01cd, 0x01cf, 0x01d1, 0x01d3, + 0x01d5, 0x01d7, 0x01d9, 0x01db, 0x018e, + 0x01de, 0x01e0, 0x01e2, 0x01e4, 0x01e6, + 0x01e8, 0x01ea, 0x01ec, 0x01ee, 0x01f1, + 0x01f4, 0x01fa, 0x01fc, 0x01fe, 0x0200, + 0x0202, 0x0204, 0x0206, 0x0208, 0x020a, + 0x020c, 0x020e, 0x0210, 0x0212, 0x0214, + 0x0216, 0x0181, 0x0186, 0x0189, 0x018f, + 0x0190, 0x0193, 0x0194, 0x0197, 0x0196, + 0x019c, 0x019d, 0x019f, 0x01a6, 0x01a9, + 0x01ae, 0x01b1, 0x01b7, 0x0399, 0x0386, + 0x0388, 0x0391, 0x03a3, 0x03a3, 0x038c, + 0x038e, 0x0392, 0x0398, 0x03a6, 0x03a0, + 0x03e2, 0x03e4, 0x03e6, 0x03e8, 0x03ea, + 0x03ec, 0x03ee, 0x039a, 0x03a1, 0x03a3, + 0x0410, 0x0401, 0x040e, 0x0460, 0x0462, + 0x0464, 0x0466, 0x0468, 0x046a, 0x046c, + 0x046e, 0x0470, 0x0472, 0x0474, 0x0476, + 0x0478, 0x047a, 0x047c, 0x047e, 0x0480, + 0x0490, 0x0492, 0x0494, 0x0496, 0x0498, + 0x049a, 0x049c, 0x049e, 0x04a0, 0x04a2, + 0x04a4, 0x04a6, 0x04a8, 0x04aa, 0x04ac, + 0x04ae, 0x04b0, 0x04b2, 0x04b4, 0x04b6, + 0x04b8, 0x04ba, 0x04bc, 0x04be, 0x04c1, + 0x04c3, 0x04c7, 0x04cb, 0x04d0, 0x04d2, + 0x04d4, 0x04d6, 0x04d8, 0x04da, 0x04dc, + 0x04de, 0x04e0, 0x04e2, 0x04e4, 0x04e6, + 0x04e8, 0x04ea, 0x04ee, 0x04f0, 0x04f2, + 0x04f4, 0x04f8, 0x0531, 0x1e00, 0x1e02, + 0x1e04, 0x1e06, 0x1e08, 0x1e0a, 0x1e0c, + 0x1e0e, 0x1e10, 0x1e12, 0x1e14, 0x1e16, + 0x1e18, 0x1e1a, 0x1e1c, 0x1e1e, 0x1e20, + 0x1e22, 0x1e24, 0x1e26, 0x1e28, 0x1e2a, + 0x1e2c, 0x1e2e, 0x1e30, 0x1e32, 0x1e34, + 0x1e36, 0x1e38, 0x1e3a, 0x1e3c, 0x1e3e, + 0x1e40, 0x1e42, 0x1e44, 0x1e46, 0x1e48, + 0x1e4a, 0x1e4c, 0x1e4e, 0x1e50, 0x1e52, + 0x1e54, 0x1e56, 0x1e58, 0x1e5a, 0x1e5c, + 0x1e5e, 0x1e60, 0x1e62, 0x1e64, 0x1e66, + 0x1e68, 0x1e6a, 0x1e6c, 0x1e6e, 0x1e70, + 0x1e72, 0x1e74, 0x1e76, 0x1e78, 0x1e7a, + 0x1e7c, 0x1e7e, 0x1e80, 0x1e82, 0x1e84, + 0x1e86, 0x1e88, 0x1e8a, 0x1e8c, 0x1e8e, + 0x1e90, 0x1e92, 0x1e94, 0x1e60, 0x1ea0, + 0x1ea2, 0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, + 0x1eac, 0x1eae, 0x1eb0, 0x1eb2, 0x1eb4, + 0x1eb6, 0x1eb8, 0x1eba, 0x1ebc, 0x1ebe, + 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6, 0x1ec8, + 0x1eca, 0x1ecc, 0x1ece, 0x1ed0, 0x1ed2, + 0x1ed4, 0x1ed6, 0x1ed8, 0x1eda, 0x1edc, + 0x1ede, 0x1ee0, 0x1ee2, 0x1ee4, 0x1ee6, + 0x1ee8, 0x1eea, 0x1eec, 0x1eee, 0x1ef0, + 0x1ef2, 0x1ef4, 0x1ef6, 0x1ef8, 0x1f08, + 0x1f18, 0x1f28, 0x1f38, 0x1f48, 0x1f59, + 0x1f5b, 0x1f5d, 0x1f5f, 0x1f68, 0x1fba, + 0x1fc8, 0x1fda, 0x1ff8, 0x1fea, 0x1ffa, + 0x1f88, 0x1f98, 0x1fa8, 0x1fb8, 0x1fbc, + 0x0399, 0x1fcc, 0x1fd8, 0x1fe8, 0x1fec, + 0x1ffc, 0x2160, 0x24b6, 0xff21 }; + +static const jchar lower_anomalous_table[] = + { 0x00df, 0x0138, 0x0149, 0x0180, 0x018d, + 0x0195, 0x019a, 0x019b, 0x019e, 0x01ab, + 0x01ba, 0x01f0, 0x0250, 0x0251, 0x0252, + 0x0255, 0x0258, 0x025a, 0x025c, 0x025d, + 0x025e, 0x025f, 0x0261, 0x0264, 0x0265, + 0x0266, 0x0267, 0x026b, 0x026c, 0x026d, + 0x026e, 0x0270, 0x0271, 0x0273, 0x0277, + 0x0278, 0x0279, 0x027a, 0x027b, 0x027c, + 0x027d, 0x027e, 0x027f, 0x0282, 0x0284, + 0x0285, 0x0286, 0x0287, 0x0289, 0x028c, + 0x028d, 0x028e, 0x0290, 0x0291, 0x0293, + 0x029a, 0x029d, 0x029e, 0x02a0, 0x02a3, + 0x02a4, 0x02a5, 0x02a6, 0x02a7, 0x02a8, + 0x0390, 0x03b0, 0x0587, 0x1e96, 0x1e97, + 0x1e98, 0x1e99, 0x1e9a, 0x1f50, 0x1f52, + 0x1f54, 0x1f56, 0x1fb2, 0x1fb4, 0x1fb6, + 0x1fb7, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fc7, + 0x1fd2, 0x1fd3, 0x1fd6, 0x1fd7, 0x1fe2, + 0x1fe3, 0x1fe4, 0x1fe6, 0x1fe7, 0x1ff2, + 0x1ff4, 0x1ff6, 0x1ff7, 0x207f, 0x2129, + 0x249c, 0x249d, 0x249e, 0x249f, 0x24a0, + 0x24a1, 0x24a2, 0x24a3, 0x24a4, 0x24a5, + 0x24a6, 0x24a7, 0x24a8, 0x24a9, 0x24aa, + 0x24ab, 0x24ac, 0x24ad, 0x24ae, 0x24af, + 0x24b0, 0x24b1, 0x24b2, 0x24b3, 0x24b4, + 0x24b5, 0xfb00, 0xfb01, 0xfb02, 0xfb03, + 0xfb04, 0xfb05, 0xfb06, 0xfb13, 0xfb14, + 0xfb15, 0xfb16, 0xfb17 }; + +static const jchar all_table[][2] = + { + { 0x0000, 0x001f }, + { 0x0020, 0x0020 }, + { 0x0021, 0x0023 }, + { 0x0024, 0x0024 }, + { 0x0025, 0x0027 }, + { 0x0028, 0x0028 }, + { 0x0029, 0x0029 }, + { 0x002a, 0x002a }, + { 0x002b, 0x002b }, + { 0x002c, 0x002c }, + { 0x002d, 0x002d }, + { 0x002e, 0x002f }, + { 0x0030, 0x0039 }, + { 0x003a, 0x003b }, + { 0x003c, 0x003e }, + { 0x003f, 0x0040 }, + { 0x0041, 0x005a }, + { 0x005b, 0x005b }, + { 0x005c, 0x005c }, + { 0x005d, 0x005d }, + { 0x005e, 0x005e }, + { 0x005f, 0x005f }, + { 0x0060, 0x0060 }, + { 0x0061, 0x007a }, + { 0x007b, 0x007b }, + { 0x007c, 0x007c }, + { 0x007d, 0x007d }, + { 0x007e, 0x007e }, + { 0x007f, 0x009f }, + { 0x00a0, 0x00a0 }, + { 0x00a1, 0x00a1 }, + { 0x00a2, 0x00a5 }, + { 0x00a6, 0x00a7 }, + { 0x00a8, 0x00a8 }, + { 0x00a9, 0x00a9 }, + { 0x00aa, 0x00aa }, + { 0x00ab, 0x00ab }, + { 0x00ac, 0x00ac }, + { 0x00ad, 0x00ad }, + { 0x00ae, 0x00ae }, + { 0x00af, 0x00af }, + { 0x00b0, 0x00b0 }, + { 0x00b1, 0x00b1 }, + { 0x00b2, 0x00b3 }, + { 0x00b4, 0x00b4 }, + { 0x00b5, 0x00b5 }, + { 0x00b6, 0x00b6 }, + { 0x00b7, 0x00b7 }, + { 0x00b8, 0x00b8 }, + { 0x00b9, 0x00b9 }, + { 0x00ba, 0x00ba }, + { 0x00bb, 0x00bb }, + { 0x00bc, 0x00be }, + { 0x00bf, 0x00bf }, + { 0x00c0, 0x00d6 }, + { 0x00d7, 0x00d7 }, + { 0x00d8, 0x00de }, + { 0x00df, 0x00f6 }, + { 0x00f7, 0x00f7 }, + { 0x00f8, 0x00ff }, + { 0x0100, 0x0100 }, + { 0x0101, 0x0101 }, + { 0x0102, 0x0102 }, + { 0x0103, 0x0103 }, + { 0x0104, 0x0104 }, + { 0x0105, 0x0105 }, + { 0x0106, 0x0106 }, + { 0x0107, 0x0107 }, + { 0x0108, 0x0108 }, + { 0x0109, 0x0109 }, + { 0x010a, 0x010a }, + { 0x010b, 0x010b }, + { 0x010c, 0x010c }, + { 0x010d, 0x010d }, + { 0x010e, 0x010e }, + { 0x010f, 0x010f }, + { 0x0110, 0x0110 }, + { 0x0111, 0x0111 }, + { 0x0112, 0x0112 }, + { 0x0113, 0x0113 }, + { 0x0114, 0x0114 }, + { 0x0115, 0x0115 }, + { 0x0116, 0x0116 }, + { 0x0117, 0x0117 }, + { 0x0118, 0x0118 }, + { 0x0119, 0x0119 }, + { 0x011a, 0x011a }, + { 0x011b, 0x011b }, + { 0x011c, 0x011c }, + { 0x011d, 0x011d }, + { 0x011e, 0x011e }, + { 0x011f, 0x011f }, + { 0x0120, 0x0120 }, + { 0x0121, 0x0121 }, + { 0x0122, 0x0122 }, + { 0x0123, 0x0123 }, + { 0x0124, 0x0124 }, + { 0x0125, 0x0125 }, + { 0x0126, 0x0126 }, + { 0x0127, 0x0127 }, + { 0x0128, 0x0128 }, + { 0x0129, 0x0129 }, + { 0x012a, 0x012a }, + { 0x012b, 0x012b }, + { 0x012c, 0x012c }, + { 0x012d, 0x012d }, + { 0x012e, 0x012e }, + { 0x012f, 0x012f }, + { 0x0130, 0x0130 }, + { 0x0131, 0x0131 }, + { 0x0132, 0x0132 }, + { 0x0133, 0x0133 }, + { 0x0134, 0x0134 }, + { 0x0135, 0x0135 }, + { 0x0136, 0x0136 }, + { 0x0137, 0x0138 }, + { 0x0139, 0x0139 }, + { 0x013a, 0x013a }, + { 0x013b, 0x013b }, + { 0x013c, 0x013c }, + { 0x013d, 0x013d }, + { 0x013e, 0x013e }, + { 0x013f, 0x013f }, + { 0x0140, 0x0140 }, + { 0x0141, 0x0141 }, + { 0x0142, 0x0142 }, + { 0x0143, 0x0143 }, + { 0x0144, 0x0144 }, + { 0x0145, 0x0145 }, + { 0x0146, 0x0146 }, + { 0x0147, 0x0147 }, + { 0x0148, 0x0149 }, + { 0x014a, 0x014a }, + { 0x014b, 0x014b }, + { 0x014c, 0x014c }, + { 0x014d, 0x014d }, + { 0x014e, 0x014e }, + { 0x014f, 0x014f }, + { 0x0150, 0x0150 }, + { 0x0151, 0x0151 }, + { 0x0152, 0x0152 }, + { 0x0153, 0x0153 }, + { 0x0154, 0x0154 }, + { 0x0155, 0x0155 }, + { 0x0156, 0x0156 }, + { 0x0157, 0x0157 }, + { 0x0158, 0x0158 }, + { 0x0159, 0x0159 }, + { 0x015a, 0x015a }, + { 0x015b, 0x015b }, + { 0x015c, 0x015c }, + { 0x015d, 0x015d }, + { 0x015e, 0x015e }, + { 0x015f, 0x015f }, + { 0x0160, 0x0160 }, + { 0x0161, 0x0161 }, + { 0x0162, 0x0162 }, + { 0x0163, 0x0163 }, + { 0x0164, 0x0164 }, + { 0x0165, 0x0165 }, + { 0x0166, 0x0166 }, + { 0x0167, 0x0167 }, + { 0x0168, 0x0168 }, + { 0x0169, 0x0169 }, + { 0x016a, 0x016a }, + { 0x016b, 0x016b }, + { 0x016c, 0x016c }, + { 0x016d, 0x016d }, + { 0x016e, 0x016e }, + { 0x016f, 0x016f }, + { 0x0170, 0x0170 }, + { 0x0171, 0x0171 }, + { 0x0172, 0x0172 }, + { 0x0173, 0x0173 }, + { 0x0174, 0x0174 }, + { 0x0175, 0x0175 }, + { 0x0176, 0x0176 }, + { 0x0177, 0x0177 }, + { 0x0178, 0x0179 }, + { 0x017a, 0x017a }, + { 0x017b, 0x017b }, + { 0x017c, 0x017c }, + { 0x017d, 0x017d }, + { 0x017e, 0x0180 }, + { 0x0181, 0x0182 }, + { 0x0183, 0x0183 }, + { 0x0184, 0x0184 }, + { 0x0185, 0x0185 }, + { 0x0186, 0x0187 }, + { 0x0188, 0x0188 }, + { 0x0189, 0x018b }, + { 0x018c, 0x018d }, + { 0x018e, 0x0191 }, + { 0x0192, 0x0192 }, + { 0x0193, 0x0194 }, + { 0x0195, 0x0195 }, + { 0x0196, 0x0198 }, + { 0x0199, 0x019b }, + { 0x019c, 0x019d }, + { 0x019e, 0x019e }, + { 0x019f, 0x01a0 }, + { 0x01a1, 0x01a1 }, + { 0x01a2, 0x01a2 }, + { 0x01a3, 0x01a3 }, + { 0x01a4, 0x01a4 }, + { 0x01a5, 0x01a5 }, + { 0x01a6, 0x01a7 }, + { 0x01a8, 0x01a8 }, + { 0x01a9, 0x01a9 }, + { 0x01aa, 0x01aa }, + { 0x01ab, 0x01ab }, + { 0x01ac, 0x01ac }, + { 0x01ad, 0x01ad }, + { 0x01ae, 0x01af }, + { 0x01b0, 0x01b0 }, + { 0x01b1, 0x01b3 }, + { 0x01b4, 0x01b4 }, + { 0x01b5, 0x01b5 }, + { 0x01b6, 0x01b6 }, + { 0x01b7, 0x01b8 }, + { 0x01b9, 0x01ba }, + { 0x01bb, 0x01bb }, + { 0x01bc, 0x01bc }, + { 0x01bd, 0x01bd }, + { 0x01be, 0x01c3 }, + { 0x01c4, 0x01c4 }, + { 0x01c5, 0x01c5 }, + { 0x01c6, 0x01c6 }, + { 0x01c7, 0x01c7 }, + { 0x01c8, 0x01c8 }, + { 0x01c9, 0x01c9 }, + { 0x01ca, 0x01ca }, + { 0x01cb, 0x01cb }, + { 0x01cc, 0x01cc }, + { 0x01cd, 0x01cd }, + { 0x01ce, 0x01ce }, + { 0x01cf, 0x01cf }, + { 0x01d0, 0x01d0 }, + { 0x01d1, 0x01d1 }, + { 0x01d2, 0x01d2 }, + { 0x01d3, 0x01d3 }, + { 0x01d4, 0x01d4 }, + { 0x01d5, 0x01d5 }, + { 0x01d6, 0x01d6 }, + { 0x01d7, 0x01d7 }, + { 0x01d8, 0x01d8 }, + { 0x01d9, 0x01d9 }, + { 0x01da, 0x01da }, + { 0x01db, 0x01db }, + { 0x01dc, 0x01dd }, + { 0x01de, 0x01de }, + { 0x01df, 0x01df }, + { 0x01e0, 0x01e0 }, + { 0x01e1, 0x01e1 }, + { 0x01e2, 0x01e2 }, + { 0x01e3, 0x01e3 }, + { 0x01e4, 0x01e4 }, + { 0x01e5, 0x01e5 }, + { 0x01e6, 0x01e6 }, + { 0x01e7, 0x01e7 }, + { 0x01e8, 0x01e8 }, + { 0x01e9, 0x01e9 }, + { 0x01ea, 0x01ea }, + { 0x01eb, 0x01eb }, + { 0x01ec, 0x01ec }, + { 0x01ed, 0x01ed }, + { 0x01ee, 0x01ee }, + { 0x01ef, 0x01f0 }, + { 0x01f1, 0x01f1 }, + { 0x01f2, 0x01f2 }, + { 0x01f3, 0x01f3 }, + { 0x01f4, 0x01f4 }, + { 0x01f5, 0x01f5 }, + { 0x01f6, 0x01f9 }, + { 0x01fa, 0x01fa }, + { 0x01fb, 0x01fb }, + { 0x01fc, 0x01fc }, + { 0x01fd, 0x01fd }, + { 0x01fe, 0x01fe }, + { 0x01ff, 0x01ff }, + { 0x0200, 0x0200 }, + { 0x0201, 0x0201 }, + { 0x0202, 0x0202 }, + { 0x0203, 0x0203 }, + { 0x0204, 0x0204 }, + { 0x0205, 0x0205 }, + { 0x0206, 0x0206 }, + { 0x0207, 0x0207 }, + { 0x0208, 0x0208 }, + { 0x0209, 0x0209 }, + { 0x020a, 0x020a }, + { 0x020b, 0x020b }, + { 0x020c, 0x020c }, + { 0x020d, 0x020d }, + { 0x020e, 0x020e }, + { 0x020f, 0x020f }, + { 0x0210, 0x0210 }, + { 0x0211, 0x0211 }, + { 0x0212, 0x0212 }, + { 0x0213, 0x0213 }, + { 0x0214, 0x0214 }, + { 0x0215, 0x0215 }, + { 0x0216, 0x0216 }, + { 0x0217, 0x0217 }, + { 0x0218, 0x024f }, + { 0x0250, 0x02a8 }, + { 0x02a9, 0x02af }, + { 0x02b0, 0x02b8 }, + { 0x02b9, 0x02ba }, + { 0x02bb, 0x02c1 }, + { 0x02c2, 0x02cf }, + { 0x02d0, 0x02d1 }, + { 0x02d2, 0x02de }, + { 0x02df, 0x02df }, + { 0x02e0, 0x02e4 }, + { 0x02e5, 0x02e9 }, + { 0x02ea, 0x02ff }, + { 0x0300, 0x0345 }, + { 0x0346, 0x035f }, + { 0x0360, 0x0361 }, + { 0x0362, 0x0373 }, + { 0x0374, 0x0375 }, + { 0x0376, 0x0379 }, + { 0x037a, 0x037a }, + { 0x037b, 0x037d }, + { 0x037e, 0x037e }, + { 0x037f, 0x0383 }, + { 0x0384, 0x0385 }, + { 0x0386, 0x0386 }, + { 0x0387, 0x0387 }, + { 0x0388, 0x038a }, + { 0x038b, 0x038b }, + { 0x038c, 0x038c }, + { 0x038d, 0x038d }, + { 0x038e, 0x038f }, + { 0x0390, 0x0390 }, + { 0x0391, 0x03a1 }, + { 0x03a2, 0x03a2 }, + { 0x03a3, 0x03ab }, + { 0x03ac, 0x03ce }, + { 0x03cf, 0x03cf }, + { 0x03d0, 0x03d1 }, + { 0x03d2, 0x03d4 }, + { 0x03d5, 0x03d6 }, + { 0x03d7, 0x03d9 }, + { 0x03da, 0x03da }, + { 0x03db, 0x03db }, + { 0x03dc, 0x03dc }, + { 0x03dd, 0x03dd }, + { 0x03de, 0x03de }, + { 0x03df, 0x03df }, + { 0x03e0, 0x03e0 }, + { 0x03e1, 0x03e1 }, + { 0x03e2, 0x03e2 }, + { 0x03e3, 0x03e3 }, + { 0x03e4, 0x03e4 }, + { 0x03e5, 0x03e5 }, + { 0x03e6, 0x03e6 }, + { 0x03e7, 0x03e7 }, + { 0x03e8, 0x03e8 }, + { 0x03e9, 0x03e9 }, + { 0x03ea, 0x03ea }, + { 0x03eb, 0x03eb }, + { 0x03ec, 0x03ec }, + { 0x03ed, 0x03ed }, + { 0x03ee, 0x03ee }, + { 0x03ef, 0x03f2 }, + { 0x03f3, 0x03f3 }, + { 0x03f4, 0x0400 }, + { 0x0401, 0x040c }, + { 0x040d, 0x040d }, + { 0x040e, 0x042f }, + { 0x0430, 0x044f }, + { 0x0450, 0x0450 }, + { 0x0451, 0x045c }, + { 0x045d, 0x045d }, + { 0x045e, 0x045f }, + { 0x0460, 0x0460 }, + { 0x0461, 0x0461 }, + { 0x0462, 0x0462 }, + { 0x0463, 0x0463 }, + { 0x0464, 0x0464 }, + { 0x0465, 0x0465 }, + { 0x0466, 0x0466 }, + { 0x0467, 0x0467 }, + { 0x0468, 0x0468 }, + { 0x0469, 0x0469 }, + { 0x046a, 0x046a }, + { 0x046b, 0x046b }, + { 0x046c, 0x046c }, + { 0x046d, 0x046d }, + { 0x046e, 0x046e }, + { 0x046f, 0x046f }, + { 0x0470, 0x0470 }, + { 0x0471, 0x0471 }, + { 0x0472, 0x0472 }, + { 0x0473, 0x0473 }, + { 0x0474, 0x0474 }, + { 0x0475, 0x0475 }, + { 0x0476, 0x0476 }, + { 0x0477, 0x0477 }, + { 0x0478, 0x0478 }, + { 0x0479, 0x0479 }, + { 0x047a, 0x047a }, + { 0x047b, 0x047b }, + { 0x047c, 0x047c }, + { 0x047d, 0x047d }, + { 0x047e, 0x047e }, + { 0x047f, 0x047f }, + { 0x0480, 0x0480 }, + { 0x0481, 0x0481 }, + { 0x0482, 0x0482 }, + { 0x0483, 0x0486 }, + { 0x0487, 0x048f }, + { 0x0490, 0x0490 }, + { 0x0491, 0x0491 }, + { 0x0492, 0x0492 }, + { 0x0493, 0x0493 }, + { 0x0494, 0x0494 }, + { 0x0495, 0x0495 }, + { 0x0496, 0x0496 }, + { 0x0497, 0x0497 }, + { 0x0498, 0x0498 }, + { 0x0499, 0x0499 }, + { 0x049a, 0x049a }, + { 0x049b, 0x049b }, + { 0x049c, 0x049c }, + { 0x049d, 0x049d }, + { 0x049e, 0x049e }, + { 0x049f, 0x049f }, + { 0x04a0, 0x04a0 }, + { 0x04a1, 0x04a1 }, + { 0x04a2, 0x04a2 }, + { 0x04a3, 0x04a3 }, + { 0x04a4, 0x04a4 }, + { 0x04a5, 0x04a5 }, + { 0x04a6, 0x04a6 }, + { 0x04a7, 0x04a7 }, + { 0x04a8, 0x04a8 }, + { 0x04a9, 0x04a9 }, + { 0x04aa, 0x04aa }, + { 0x04ab, 0x04ab }, + { 0x04ac, 0x04ac }, + { 0x04ad, 0x04ad }, + { 0x04ae, 0x04ae }, + { 0x04af, 0x04af }, + { 0x04b0, 0x04b0 }, + { 0x04b1, 0x04b1 }, + { 0x04b2, 0x04b2 }, + { 0x04b3, 0x04b3 }, + { 0x04b4, 0x04b4 }, + { 0x04b5, 0x04b5 }, + { 0x04b6, 0x04b6 }, + { 0x04b7, 0x04b7 }, + { 0x04b8, 0x04b8 }, + { 0x04b9, 0x04b9 }, + { 0x04ba, 0x04ba }, + { 0x04bb, 0x04bb }, + { 0x04bc, 0x04bc }, + { 0x04bd, 0x04bd }, + { 0x04be, 0x04be }, + { 0x04bf, 0x04bf }, + { 0x04c0, 0x04c0 }, + { 0x04c1, 0x04c1 }, + { 0x04c2, 0x04c2 }, + { 0x04c3, 0x04c3 }, + { 0x04c4, 0x04c4 }, + { 0x04c5, 0x04c6 }, + { 0x04c7, 0x04c7 }, + { 0x04c8, 0x04c8 }, + { 0x04c9, 0x04ca }, + { 0x04cb, 0x04cb }, + { 0x04cc, 0x04cc }, + { 0x04cd, 0x04cf }, + { 0x04d0, 0x04d0 }, + { 0x04d1, 0x04d1 }, + { 0x04d2, 0x04d2 }, + { 0x04d3, 0x04d3 }, + { 0x04d4, 0x04d4 }, + { 0x04d5, 0x04d5 }, + { 0x04d6, 0x04d6 }, + { 0x04d7, 0x04d7 }, + { 0x04d8, 0x04d8 }, + { 0x04d9, 0x04d9 }, + { 0x04da, 0x04da }, + { 0x04db, 0x04db }, + { 0x04dc, 0x04dc }, + { 0x04dd, 0x04dd }, + { 0x04de, 0x04de }, + { 0x04df, 0x04df }, + { 0x04e0, 0x04e0 }, + { 0x04e1, 0x04e1 }, + { 0x04e2, 0x04e2 }, + { 0x04e3, 0x04e3 }, + { 0x04e4, 0x04e4 }, + { 0x04e5, 0x04e5 }, + { 0x04e6, 0x04e6 }, + { 0x04e7, 0x04e7 }, + { 0x04e8, 0x04e8 }, + { 0x04e9, 0x04e9 }, + { 0x04ea, 0x04ea }, + { 0x04eb, 0x04eb }, + { 0x04ec, 0x04ed }, + { 0x04ee, 0x04ee }, + { 0x04ef, 0x04ef }, + { 0x04f0, 0x04f0 }, + { 0x04f1, 0x04f1 }, + { 0x04f2, 0x04f2 }, + { 0x04f3, 0x04f3 }, + { 0x04f4, 0x04f4 }, + { 0x04f5, 0x04f5 }, + { 0x04f6, 0x04f7 }, + { 0x04f8, 0x04f8 }, + { 0x04f9, 0x04f9 }, + { 0x04fa, 0x0530 }, + { 0x0531, 0x0556 }, + { 0x0557, 0x0558 }, + { 0x0559, 0x0559 }, + { 0x055a, 0x055f }, + { 0x0560, 0x0560 }, + { 0x0561, 0x0587 }, + { 0x0588, 0x0588 }, + { 0x0589, 0x0589 }, + { 0x058a, 0x0590 }, + { 0x0591, 0x05a1 }, + { 0x05a2, 0x05a2 }, + { 0x05a3, 0x05b9 }, + { 0x05ba, 0x05ba }, + { 0x05bb, 0x05bd }, + { 0x05be, 0x05be }, + { 0x05bf, 0x05bf }, + { 0x05c0, 0x05c0 }, + { 0x05c1, 0x05c2 }, + { 0x05c3, 0x05c3 }, + { 0x05c4, 0x05c4 }, + { 0x05c5, 0x05cf }, + { 0x05d0, 0x05ea }, + { 0x05eb, 0x05ef }, + { 0x05f0, 0x05f2 }, + { 0x05f3, 0x05f4 }, + { 0x05f5, 0x060b }, + { 0x060c, 0x060c }, + { 0x060d, 0x061a }, + { 0x061b, 0x061b }, + { 0x061c, 0x061e }, + { 0x061f, 0x061f }, + { 0x0620, 0x0620 }, + { 0x0621, 0x063a }, + { 0x063b, 0x063f }, + { 0x0640, 0x0640 }, + { 0x0641, 0x064a }, + { 0x064b, 0x0652 }, + { 0x0653, 0x065f }, + { 0x0660, 0x0669 }, + { 0x066a, 0x066d }, + { 0x066e, 0x066f }, + { 0x0670, 0x0670 }, + { 0x0671, 0x06b7 }, + { 0x06b8, 0x06b9 }, + { 0x06ba, 0x06be }, + { 0x06bf, 0x06bf }, + { 0x06c0, 0x06ce }, + { 0x06cf, 0x06cf }, + { 0x06d0, 0x06d3 }, + { 0x06d4, 0x06d4 }, + { 0x06d5, 0x06d5 }, + { 0x06d6, 0x06dc }, + { 0x06dd, 0x06de }, + { 0x06df, 0x06e4 }, + { 0x06e5, 0x06e6 }, + { 0x06e7, 0x06e8 }, + { 0x06e9, 0x06e9 }, + { 0x06ea, 0x06ed }, + { 0x06ee, 0x06ef }, + { 0x06f0, 0x06f9 }, + { 0x06fa, 0x0900 }, + { 0x0901, 0x0902 }, + { 0x0903, 0x0903 }, + { 0x0904, 0x0904 }, + { 0x0905, 0x0939 }, + { 0x093a, 0x093b }, + { 0x093c, 0x093c }, + { 0x093d, 0x093d }, + { 0x093e, 0x0940 }, + { 0x0941, 0x0948 }, + { 0x0949, 0x094c }, + { 0x094d, 0x094d }, + { 0x094e, 0x094f }, + { 0x0950, 0x0950 }, + { 0x0951, 0x0954 }, + { 0x0955, 0x0957 }, + { 0x0958, 0x0961 }, + { 0x0962, 0x0963 }, + { 0x0964, 0x0965 }, + { 0x0966, 0x096f }, + { 0x0970, 0x0970 }, + { 0x0971, 0x0980 }, + { 0x0981, 0x0981 }, + { 0x0982, 0x0983 }, + { 0x0984, 0x0984 }, + { 0x0985, 0x098c }, + { 0x098d, 0x098e }, + { 0x098f, 0x0990 }, + { 0x0991, 0x0992 }, + { 0x0993, 0x09a8 }, + { 0x09a9, 0x09a9 }, + { 0x09aa, 0x09b0 }, + { 0x09b1, 0x09b1 }, + { 0x09b2, 0x09b2 }, + { 0x09b3, 0x09b5 }, + { 0x09b6, 0x09b9 }, + { 0x09ba, 0x09bb }, + { 0x09bc, 0x09bc }, + { 0x09bd, 0x09bd }, + { 0x09be, 0x09c0 }, + { 0x09c1, 0x09c4 }, + { 0x09c5, 0x09c6 }, + { 0x09c7, 0x09c8 }, + { 0x09c9, 0x09ca }, + { 0x09cb, 0x09cc }, + { 0x09cd, 0x09cd }, + { 0x09ce, 0x09d6 }, + { 0x09d7, 0x09d7 }, + { 0x09d8, 0x09db }, + { 0x09dc, 0x09dd }, + { 0x09de, 0x09de }, + { 0x09df, 0x09e1 }, + { 0x09e2, 0x09e3 }, + { 0x09e4, 0x09e5 }, + { 0x09e6, 0x09ef }, + { 0x09f0, 0x09f1 }, + { 0x09f2, 0x09f3 }, + { 0x09f4, 0x09f9 }, + { 0x09fa, 0x09fa }, + { 0x09fb, 0x0a01 }, + { 0x0a02, 0x0a02 }, + { 0x0a03, 0x0a04 }, + { 0x0a05, 0x0a0a }, + { 0x0a0b, 0x0a0e }, + { 0x0a0f, 0x0a10 }, + { 0x0a11, 0x0a12 }, + { 0x0a13, 0x0a28 }, + { 0x0a29, 0x0a29 }, + { 0x0a2a, 0x0a30 }, + { 0x0a31, 0x0a31 }, + { 0x0a32, 0x0a33 }, + { 0x0a34, 0x0a34 }, + { 0x0a35, 0x0a36 }, + { 0x0a37, 0x0a37 }, + { 0x0a38, 0x0a39 }, + { 0x0a3a, 0x0a3b }, + { 0x0a3c, 0x0a3c }, + { 0x0a3d, 0x0a3d }, + { 0x0a3e, 0x0a40 }, + { 0x0a41, 0x0a42 }, + { 0x0a43, 0x0a46 }, + { 0x0a47, 0x0a48 }, + { 0x0a49, 0x0a4a }, + { 0x0a4b, 0x0a4d }, + { 0x0a4e, 0x0a58 }, + { 0x0a59, 0x0a5c }, + { 0x0a5d, 0x0a5d }, + { 0x0a5e, 0x0a5e }, + { 0x0a5f, 0x0a65 }, + { 0x0a66, 0x0a6f }, + { 0x0a70, 0x0a71 }, + { 0x0a72, 0x0a74 }, + { 0x0a75, 0x0a80 }, + { 0x0a81, 0x0a82 }, + { 0x0a83, 0x0a83 }, + { 0x0a84, 0x0a84 }, + { 0x0a85, 0x0a8b }, + { 0x0a8c, 0x0a8c }, + { 0x0a8d, 0x0a8d }, + { 0x0a8e, 0x0a8e }, + { 0x0a8f, 0x0a91 }, + { 0x0a92, 0x0a92 }, + { 0x0a93, 0x0aa8 }, + { 0x0aa9, 0x0aa9 }, + { 0x0aaa, 0x0ab0 }, + { 0x0ab1, 0x0ab1 }, + { 0x0ab2, 0x0ab3 }, + { 0x0ab4, 0x0ab4 }, + { 0x0ab5, 0x0ab9 }, + { 0x0aba, 0x0abb }, + { 0x0abc, 0x0abc }, + { 0x0abd, 0x0abd }, + { 0x0abe, 0x0ac0 }, + { 0x0ac1, 0x0ac5 }, + { 0x0ac6, 0x0ac6 }, + { 0x0ac7, 0x0ac8 }, + { 0x0ac9, 0x0ac9 }, + { 0x0aca, 0x0aca }, + { 0x0acb, 0x0acc }, + { 0x0acd, 0x0acd }, + { 0x0ace, 0x0acf }, + { 0x0ad0, 0x0ad0 }, + { 0x0ad1, 0x0adf }, + { 0x0ae0, 0x0ae0 }, + { 0x0ae1, 0x0ae5 }, + { 0x0ae6, 0x0aef }, + { 0x0af0, 0x0b00 }, + { 0x0b01, 0x0b01 }, + { 0x0b02, 0x0b03 }, + { 0x0b04, 0x0b04 }, + { 0x0b05, 0x0b0c }, + { 0x0b0d, 0x0b0e }, + { 0x0b0f, 0x0b10 }, + { 0x0b11, 0x0b12 }, + { 0x0b13, 0x0b28 }, + { 0x0b29, 0x0b29 }, + { 0x0b2a, 0x0b30 }, + { 0x0b31, 0x0b31 }, + { 0x0b32, 0x0b33 }, + { 0x0b34, 0x0b35 }, + { 0x0b36, 0x0b39 }, + { 0x0b3a, 0x0b3b }, + { 0x0b3c, 0x0b3c }, + { 0x0b3d, 0x0b3d }, + { 0x0b3e, 0x0b3e }, + { 0x0b3f, 0x0b3f }, + { 0x0b40, 0x0b40 }, + { 0x0b41, 0x0b43 }, + { 0x0b44, 0x0b46 }, + { 0x0b47, 0x0b48 }, + { 0x0b49, 0x0b4a }, + { 0x0b4b, 0x0b4c }, + { 0x0b4d, 0x0b4d }, + { 0x0b4e, 0x0b55 }, + { 0x0b56, 0x0b56 }, + { 0x0b57, 0x0b57 }, + { 0x0b58, 0x0b5b }, + { 0x0b5c, 0x0b5d }, + { 0x0b5e, 0x0b5e }, + { 0x0b5f, 0x0b61 }, + { 0x0b62, 0x0b65 }, + { 0x0b66, 0x0b6f }, + { 0x0b70, 0x0b70 }, + { 0x0b71, 0x0b81 }, + { 0x0b82, 0x0b82 }, + { 0x0b83, 0x0b83 }, + { 0x0b84, 0x0b84 }, + { 0x0b85, 0x0b8a }, + { 0x0b8b, 0x0b8d }, + { 0x0b8e, 0x0b90 }, + { 0x0b91, 0x0b91 }, + { 0x0b92, 0x0b95 }, + { 0x0b96, 0x0b98 }, + { 0x0b99, 0x0b9a }, + { 0x0b9b, 0x0b9b }, + { 0x0b9c, 0x0b9c }, + { 0x0b9d, 0x0b9d }, + { 0x0b9e, 0x0b9f }, + { 0x0ba0, 0x0ba2 }, + { 0x0ba3, 0x0ba4 }, + { 0x0ba5, 0x0ba7 }, + { 0x0ba8, 0x0baa }, + { 0x0bab, 0x0bad }, + { 0x0bae, 0x0bb5 }, + { 0x0bb6, 0x0bb6 }, + { 0x0bb7, 0x0bb9 }, + { 0x0bba, 0x0bbd }, + { 0x0bbe, 0x0bbf }, + { 0x0bc0, 0x0bc0 }, + { 0x0bc1, 0x0bc2 }, + { 0x0bc3, 0x0bc5 }, + { 0x0bc6, 0x0bc8 }, + { 0x0bc9, 0x0bc9 }, + { 0x0bca, 0x0bcc }, + { 0x0bcd, 0x0bcd }, + { 0x0bce, 0x0bd6 }, + { 0x0bd7, 0x0bd7 }, + { 0x0bd8, 0x0be6 }, + { 0x0be7, 0x0bef }, + { 0x0bf0, 0x0bf2 }, + { 0x0bf3, 0x0c00 }, + { 0x0c01, 0x0c03 }, + { 0x0c04, 0x0c04 }, + { 0x0c05, 0x0c0c }, + { 0x0c0d, 0x0c0d }, + { 0x0c0e, 0x0c10 }, + { 0x0c11, 0x0c11 }, + { 0x0c12, 0x0c28 }, + { 0x0c29, 0x0c29 }, + { 0x0c2a, 0x0c33 }, + { 0x0c34, 0x0c34 }, + { 0x0c35, 0x0c39 }, + { 0x0c3a, 0x0c3d }, + { 0x0c3e, 0x0c40 }, + { 0x0c41, 0x0c44 }, + { 0x0c45, 0x0c45 }, + { 0x0c46, 0x0c48 }, + { 0x0c49, 0x0c49 }, + { 0x0c4a, 0x0c4d }, + { 0x0c4e, 0x0c54 }, + { 0x0c55, 0x0c56 }, + { 0x0c57, 0x0c5f }, + { 0x0c60, 0x0c61 }, + { 0x0c62, 0x0c65 }, + { 0x0c66, 0x0c6f }, + { 0x0c70, 0x0c81 }, + { 0x0c82, 0x0c83 }, + { 0x0c84, 0x0c84 }, + { 0x0c85, 0x0c8c }, + { 0x0c8d, 0x0c8d }, + { 0x0c8e, 0x0c90 }, + { 0x0c91, 0x0c91 }, + { 0x0c92, 0x0ca8 }, + { 0x0ca9, 0x0ca9 }, + { 0x0caa, 0x0cb3 }, + { 0x0cb4, 0x0cb4 }, + { 0x0cb5, 0x0cb9 }, + { 0x0cba, 0x0cbd }, + { 0x0cbe, 0x0cbe }, + { 0x0cbf, 0x0cbf }, + { 0x0cc0, 0x0cc4 }, + { 0x0cc5, 0x0cc5 }, + { 0x0cc6, 0x0cc6 }, + { 0x0cc7, 0x0cc8 }, + { 0x0cc9, 0x0cc9 }, + { 0x0cca, 0x0ccb }, + { 0x0ccc, 0x0ccd }, + { 0x0cce, 0x0cd4 }, + { 0x0cd5, 0x0cd6 }, + { 0x0cd7, 0x0cdd }, + { 0x0cde, 0x0cde }, + { 0x0cdf, 0x0cdf }, + { 0x0ce0, 0x0ce1 }, + { 0x0ce2, 0x0ce5 }, + { 0x0ce6, 0x0cef }, + { 0x0cf0, 0x0d01 }, + { 0x0d02, 0x0d03 }, + { 0x0d04, 0x0d04 }, + { 0x0d05, 0x0d0c }, + { 0x0d0d, 0x0d0d }, + { 0x0d0e, 0x0d10 }, + { 0x0d11, 0x0d11 }, + { 0x0d12, 0x0d28 }, + { 0x0d29, 0x0d29 }, + { 0x0d2a, 0x0d39 }, + { 0x0d3a, 0x0d3d }, + { 0x0d3e, 0x0d40 }, + { 0x0d41, 0x0d43 }, + { 0x0d44, 0x0d45 }, + { 0x0d46, 0x0d48 }, + { 0x0d49, 0x0d49 }, + { 0x0d4a, 0x0d4c }, + { 0x0d4d, 0x0d4d }, + { 0x0d4e, 0x0d56 }, + { 0x0d57, 0x0d57 }, + { 0x0d58, 0x0d5f }, + { 0x0d60, 0x0d61 }, + { 0x0d62, 0x0d65 }, + { 0x0d66, 0x0d6f }, + { 0x0d70, 0x0e00 }, + { 0x0e01, 0x0e30 }, + { 0x0e31, 0x0e31 }, + { 0x0e32, 0x0e33 }, + { 0x0e34, 0x0e3a }, + { 0x0e3b, 0x0e3e }, + { 0x0e3f, 0x0e3f }, + { 0x0e40, 0x0e45 }, + { 0x0e46, 0x0e46 }, + { 0x0e47, 0x0e4e }, + { 0x0e4f, 0x0e4f }, + { 0x0e50, 0x0e59 }, + { 0x0e5a, 0x0e5b }, + { 0x0e5c, 0x0e80 }, + { 0x0e81, 0x0e82 }, + { 0x0e83, 0x0e83 }, + { 0x0e84, 0x0e84 }, + { 0x0e85, 0x0e86 }, + { 0x0e87, 0x0e88 }, + { 0x0e89, 0x0e89 }, + { 0x0e8a, 0x0e8a }, + { 0x0e8b, 0x0e8c }, + { 0x0e8d, 0x0e8d }, + { 0x0e8e, 0x0e93 }, + { 0x0e94, 0x0e97 }, + { 0x0e98, 0x0e98 }, + { 0x0e99, 0x0e9f }, + { 0x0ea0, 0x0ea0 }, + { 0x0ea1, 0x0ea3 }, + { 0x0ea4, 0x0ea4 }, + { 0x0ea5, 0x0ea5 }, + { 0x0ea6, 0x0ea6 }, + { 0x0ea7, 0x0ea7 }, + { 0x0ea8, 0x0ea9 }, + { 0x0eaa, 0x0eab }, + { 0x0eac, 0x0eac }, + { 0x0ead, 0x0eb0 }, + { 0x0eb1, 0x0eb1 }, + { 0x0eb2, 0x0eb3 }, + { 0x0eb4, 0x0eb9 }, + { 0x0eba, 0x0eba }, + { 0x0ebb, 0x0ebc }, + { 0x0ebd, 0x0ebd }, + { 0x0ebe, 0x0ebf }, + { 0x0ec0, 0x0ec4 }, + { 0x0ec5, 0x0ec5 }, + { 0x0ec6, 0x0ec6 }, + { 0x0ec7, 0x0ec7 }, + { 0x0ec8, 0x0ecd }, + { 0x0ece, 0x0ecf }, + { 0x0ed0, 0x0ed9 }, + { 0x0eda, 0x0edb }, + { 0x0edc, 0x0edd }, + { 0x0ede, 0x0eff }, + { 0x0f00, 0x0f00 }, + { 0x0f01, 0x0f03 }, + { 0x0f04, 0x0f12 }, + { 0x0f13, 0x0f17 }, + { 0x0f18, 0x0f19 }, + { 0x0f1a, 0x0f1f }, + { 0x0f20, 0x0f29 }, + { 0x0f2a, 0x0f33 }, + { 0x0f34, 0x0f34 }, + { 0x0f35, 0x0f35 }, + { 0x0f36, 0x0f36 }, + { 0x0f37, 0x0f37 }, + { 0x0f38, 0x0f38 }, + { 0x0f39, 0x0f39 }, + { 0x0f3a, 0x0f3a }, + { 0x0f3b, 0x0f3b }, + { 0x0f3c, 0x0f3c }, + { 0x0f3d, 0x0f3d }, + { 0x0f3e, 0x0f3f }, + { 0x0f40, 0x0f47 }, + { 0x0f48, 0x0f48 }, + { 0x0f49, 0x0f69 }, + { 0x0f6a, 0x0f70 }, + { 0x0f71, 0x0f7e }, + { 0x0f7f, 0x0f7f }, + { 0x0f80, 0x0f84 }, + { 0x0f85, 0x0f85 }, + { 0x0f86, 0x0f87 }, + { 0x0f88, 0x0f8b }, + { 0x0f8c, 0x0f8f }, + { 0x0f90, 0x0f95 }, + { 0x0f96, 0x0f96 }, + { 0x0f97, 0x0f97 }, + { 0x0f98, 0x0f98 }, + { 0x0f99, 0x0fad }, + { 0x0fae, 0x0fb0 }, + { 0x0fb1, 0x0fb7 }, + { 0x0fb8, 0x0fb8 }, + { 0x0fb9, 0x0fb9 }, + { 0x0fba, 0x109f }, + { 0x10a0, 0x10c5 }, + { 0x10c6, 0x10cf }, + { 0x10d0, 0x10f6 }, + { 0x10f7, 0x10fa }, + { 0x10fb, 0x10fb }, + { 0x10fc, 0x10ff }, + { 0x1100, 0x1159 }, + { 0x115a, 0x115e }, + { 0x115f, 0x11a2 }, + { 0x11a3, 0x11a7 }, + { 0x11a8, 0x11f9 }, + { 0x11fa, 0x1dff }, + { 0x1e00, 0x1e00 }, + { 0x1e01, 0x1e01 }, + { 0x1e02, 0x1e02 }, + { 0x1e03, 0x1e03 }, + { 0x1e04, 0x1e04 }, + { 0x1e05, 0x1e05 }, + { 0x1e06, 0x1e06 }, + { 0x1e07, 0x1e07 }, + { 0x1e08, 0x1e08 }, + { 0x1e09, 0x1e09 }, + { 0x1e0a, 0x1e0a }, + { 0x1e0b, 0x1e0b }, + { 0x1e0c, 0x1e0c }, + { 0x1e0d, 0x1e0d }, + { 0x1e0e, 0x1e0e }, + { 0x1e0f, 0x1e0f }, + { 0x1e10, 0x1e10 }, + { 0x1e11, 0x1e11 }, + { 0x1e12, 0x1e12 }, + { 0x1e13, 0x1e13 }, + { 0x1e14, 0x1e14 }, + { 0x1e15, 0x1e15 }, + { 0x1e16, 0x1e16 }, + { 0x1e17, 0x1e17 }, + { 0x1e18, 0x1e18 }, + { 0x1e19, 0x1e19 }, + { 0x1e1a, 0x1e1a }, + { 0x1e1b, 0x1e1b }, + { 0x1e1c, 0x1e1c }, + { 0x1e1d, 0x1e1d }, + { 0x1e1e, 0x1e1e }, + { 0x1e1f, 0x1e1f }, + { 0x1e20, 0x1e20 }, + { 0x1e21, 0x1e21 }, + { 0x1e22, 0x1e22 }, + { 0x1e23, 0x1e23 }, + { 0x1e24, 0x1e24 }, + { 0x1e25, 0x1e25 }, + { 0x1e26, 0x1e26 }, + { 0x1e27, 0x1e27 }, + { 0x1e28, 0x1e28 }, + { 0x1e29, 0x1e29 }, + { 0x1e2a, 0x1e2a }, + { 0x1e2b, 0x1e2b }, + { 0x1e2c, 0x1e2c }, + { 0x1e2d, 0x1e2d }, + { 0x1e2e, 0x1e2e }, + { 0x1e2f, 0x1e2f }, + { 0x1e30, 0x1e30 }, + { 0x1e31, 0x1e31 }, + { 0x1e32, 0x1e32 }, + { 0x1e33, 0x1e33 }, + { 0x1e34, 0x1e34 }, + { 0x1e35, 0x1e35 }, + { 0x1e36, 0x1e36 }, + { 0x1e37, 0x1e37 }, + { 0x1e38, 0x1e38 }, + { 0x1e39, 0x1e39 }, + { 0x1e3a, 0x1e3a }, + { 0x1e3b, 0x1e3b }, + { 0x1e3c, 0x1e3c }, + { 0x1e3d, 0x1e3d }, + { 0x1e3e, 0x1e3e }, + { 0x1e3f, 0x1e3f }, + { 0x1e40, 0x1e40 }, + { 0x1e41, 0x1e41 }, + { 0x1e42, 0x1e42 }, + { 0x1e43, 0x1e43 }, + { 0x1e44, 0x1e44 }, + { 0x1e45, 0x1e45 }, + { 0x1e46, 0x1e46 }, + { 0x1e47, 0x1e47 }, + { 0x1e48, 0x1e48 }, + { 0x1e49, 0x1e49 }, + { 0x1e4a, 0x1e4a }, + { 0x1e4b, 0x1e4b }, + { 0x1e4c, 0x1e4c }, + { 0x1e4d, 0x1e4d }, + { 0x1e4e, 0x1e4e }, + { 0x1e4f, 0x1e4f }, + { 0x1e50, 0x1e50 }, + { 0x1e51, 0x1e51 }, + { 0x1e52, 0x1e52 }, + { 0x1e53, 0x1e53 }, + { 0x1e54, 0x1e54 }, + { 0x1e55, 0x1e55 }, + { 0x1e56, 0x1e56 }, + { 0x1e57, 0x1e57 }, + { 0x1e58, 0x1e58 }, + { 0x1e59, 0x1e59 }, + { 0x1e5a, 0x1e5a }, + { 0x1e5b, 0x1e5b }, + { 0x1e5c, 0x1e5c }, + { 0x1e5d, 0x1e5d }, + { 0x1e5e, 0x1e5e }, + { 0x1e5f, 0x1e5f }, + { 0x1e60, 0x1e60 }, + { 0x1e61, 0x1e61 }, + { 0x1e62, 0x1e62 }, + { 0x1e63, 0x1e63 }, + { 0x1e64, 0x1e64 }, + { 0x1e65, 0x1e65 }, + { 0x1e66, 0x1e66 }, + { 0x1e67, 0x1e67 }, + { 0x1e68, 0x1e68 }, + { 0x1e69, 0x1e69 }, + { 0x1e6a, 0x1e6a }, + { 0x1e6b, 0x1e6b }, + { 0x1e6c, 0x1e6c }, + { 0x1e6d, 0x1e6d }, + { 0x1e6e, 0x1e6e }, + { 0x1e6f, 0x1e6f }, + { 0x1e70, 0x1e70 }, + { 0x1e71, 0x1e71 }, + { 0x1e72, 0x1e72 }, + { 0x1e73, 0x1e73 }, + { 0x1e74, 0x1e74 }, + { 0x1e75, 0x1e75 }, + { 0x1e76, 0x1e76 }, + { 0x1e77, 0x1e77 }, + { 0x1e78, 0x1e78 }, + { 0x1e79, 0x1e79 }, + { 0x1e7a, 0x1e7a }, + { 0x1e7b, 0x1e7b }, + { 0x1e7c, 0x1e7c }, + { 0x1e7d, 0x1e7d }, + { 0x1e7e, 0x1e7e }, + { 0x1e7f, 0x1e7f }, + { 0x1e80, 0x1e80 }, + { 0x1e81, 0x1e81 }, + { 0x1e82, 0x1e82 }, + { 0x1e83, 0x1e83 }, + { 0x1e84, 0x1e84 }, + { 0x1e85, 0x1e85 }, + { 0x1e86, 0x1e86 }, + { 0x1e87, 0x1e87 }, + { 0x1e88, 0x1e88 }, + { 0x1e89, 0x1e89 }, + { 0x1e8a, 0x1e8a }, + { 0x1e8b, 0x1e8b }, + { 0x1e8c, 0x1e8c }, + { 0x1e8d, 0x1e8d }, + { 0x1e8e, 0x1e8e }, + { 0x1e8f, 0x1e8f }, + { 0x1e90, 0x1e90 }, + { 0x1e91, 0x1e91 }, + { 0x1e92, 0x1e92 }, + { 0x1e93, 0x1e93 }, + { 0x1e94, 0x1e94 }, + { 0x1e95, 0x1e9b }, + { 0x1e9c, 0x1e9f }, + { 0x1ea0, 0x1ea0 }, + { 0x1ea1, 0x1ea1 }, + { 0x1ea2, 0x1ea2 }, + { 0x1ea3, 0x1ea3 }, + { 0x1ea4, 0x1ea4 }, + { 0x1ea5, 0x1ea5 }, + { 0x1ea6, 0x1ea6 }, + { 0x1ea7, 0x1ea7 }, + { 0x1ea8, 0x1ea8 }, + { 0x1ea9, 0x1ea9 }, + { 0x1eaa, 0x1eaa }, + { 0x1eab, 0x1eab }, + { 0x1eac, 0x1eac }, + { 0x1ead, 0x1ead }, + { 0x1eae, 0x1eae }, + { 0x1eaf, 0x1eaf }, + { 0x1eb0, 0x1eb0 }, + { 0x1eb1, 0x1eb1 }, + { 0x1eb2, 0x1eb2 }, + { 0x1eb3, 0x1eb3 }, + { 0x1eb4, 0x1eb4 }, + { 0x1eb5, 0x1eb5 }, + { 0x1eb6, 0x1eb6 }, + { 0x1eb7, 0x1eb7 }, + { 0x1eb8, 0x1eb8 }, + { 0x1eb9, 0x1eb9 }, + { 0x1eba, 0x1eba }, + { 0x1ebb, 0x1ebb }, + { 0x1ebc, 0x1ebc }, + { 0x1ebd, 0x1ebd }, + { 0x1ebe, 0x1ebe }, + { 0x1ebf, 0x1ebf }, + { 0x1ec0, 0x1ec0 }, + { 0x1ec1, 0x1ec1 }, + { 0x1ec2, 0x1ec2 }, + { 0x1ec3, 0x1ec3 }, + { 0x1ec4, 0x1ec4 }, + { 0x1ec5, 0x1ec5 }, + { 0x1ec6, 0x1ec6 }, + { 0x1ec7, 0x1ec7 }, + { 0x1ec8, 0x1ec8 }, + { 0x1ec9, 0x1ec9 }, + { 0x1eca, 0x1eca }, + { 0x1ecb, 0x1ecb }, + { 0x1ecc, 0x1ecc }, + { 0x1ecd, 0x1ecd }, + { 0x1ece, 0x1ece }, + { 0x1ecf, 0x1ecf }, + { 0x1ed0, 0x1ed0 }, + { 0x1ed1, 0x1ed1 }, + { 0x1ed2, 0x1ed2 }, + { 0x1ed3, 0x1ed3 }, + { 0x1ed4, 0x1ed4 }, + { 0x1ed5, 0x1ed5 }, + { 0x1ed6, 0x1ed6 }, + { 0x1ed7, 0x1ed7 }, + { 0x1ed8, 0x1ed8 }, + { 0x1ed9, 0x1ed9 }, + { 0x1eda, 0x1eda }, + { 0x1edb, 0x1edb }, + { 0x1edc, 0x1edc }, + { 0x1edd, 0x1edd }, + { 0x1ede, 0x1ede }, + { 0x1edf, 0x1edf }, + { 0x1ee0, 0x1ee0 }, + { 0x1ee1, 0x1ee1 }, + { 0x1ee2, 0x1ee2 }, + { 0x1ee3, 0x1ee3 }, + { 0x1ee4, 0x1ee4 }, + { 0x1ee5, 0x1ee5 }, + { 0x1ee6, 0x1ee6 }, + { 0x1ee7, 0x1ee7 }, + { 0x1ee8, 0x1ee8 }, + { 0x1ee9, 0x1ee9 }, + { 0x1eea, 0x1eea }, + { 0x1eeb, 0x1eeb }, + { 0x1eec, 0x1eec }, + { 0x1eed, 0x1eed }, + { 0x1eee, 0x1eee }, + { 0x1eef, 0x1eef }, + { 0x1ef0, 0x1ef0 }, + { 0x1ef1, 0x1ef1 }, + { 0x1ef2, 0x1ef2 }, + { 0x1ef3, 0x1ef3 }, + { 0x1ef4, 0x1ef4 }, + { 0x1ef5, 0x1ef5 }, + { 0x1ef6, 0x1ef6 }, + { 0x1ef7, 0x1ef7 }, + { 0x1ef8, 0x1ef8 }, + { 0x1ef9, 0x1ef9 }, + { 0x1efa, 0x1eff }, + { 0x1f00, 0x1f07 }, + { 0x1f08, 0x1f0f }, + { 0x1f10, 0x1f15 }, + { 0x1f16, 0x1f17 }, + { 0x1f18, 0x1f1d }, + { 0x1f1e, 0x1f1f }, + { 0x1f20, 0x1f27 }, + { 0x1f28, 0x1f2f }, + { 0x1f30, 0x1f37 }, + { 0x1f38, 0x1f3f }, + { 0x1f40, 0x1f45 }, + { 0x1f46, 0x1f47 }, + { 0x1f48, 0x1f4d }, + { 0x1f4e, 0x1f4f }, + { 0x1f50, 0x1f57 }, + { 0x1f58, 0x1f58 }, + { 0x1f59, 0x1f59 }, + { 0x1f5a, 0x1f5a }, + { 0x1f5b, 0x1f5b }, + { 0x1f5c, 0x1f5c }, + { 0x1f5d, 0x1f5d }, + { 0x1f5e, 0x1f5e }, + { 0x1f5f, 0x1f5f }, + { 0x1f60, 0x1f67 }, + { 0x1f68, 0x1f6f }, + { 0x1f70, 0x1f7d }, + { 0x1f7e, 0x1f7f }, + { 0x1f80, 0x1f87 }, + { 0x1f88, 0x1f8f }, + { 0x1f90, 0x1f97 }, + { 0x1f98, 0x1f9f }, + { 0x1fa0, 0x1fa7 }, + { 0x1fa8, 0x1faf }, + { 0x1fb0, 0x1fb4 }, + { 0x1fb5, 0x1fb5 }, + { 0x1fb6, 0x1fb7 }, + { 0x1fb8, 0x1fbc }, + { 0x1fbd, 0x1fbd }, + { 0x1fbe, 0x1fbe }, + { 0x1fbf, 0x1fc1 }, + { 0x1fc2, 0x1fc4 }, + { 0x1fc5, 0x1fc5 }, + { 0x1fc6, 0x1fc7 }, + { 0x1fc8, 0x1fcc }, + { 0x1fcd, 0x1fcf }, + { 0x1fd0, 0x1fd3 }, + { 0x1fd4, 0x1fd5 }, + { 0x1fd6, 0x1fd7 }, + { 0x1fd8, 0x1fdb }, + { 0x1fdc, 0x1fdc }, + { 0x1fdd, 0x1fdf }, + { 0x1fe0, 0x1fe7 }, + { 0x1fe8, 0x1fec }, + { 0x1fed, 0x1fef }, + { 0x1ff0, 0x1ff1 }, + { 0x1ff2, 0x1ff4 }, + { 0x1ff5, 0x1ff5 }, + { 0x1ff6, 0x1ff7 }, + { 0x1ff8, 0x1ffc }, + { 0x1ffd, 0x1ffe }, + { 0x1fff, 0x1fff }, + { 0x2000, 0x200b }, + { 0x200c, 0x200f }, + { 0x2010, 0x2015 }, + { 0x2016, 0x2017 }, + { 0x2018, 0x2018 }, + { 0x2019, 0x2019 }, + { 0x201a, 0x201a }, + { 0x201b, 0x201c }, + { 0x201d, 0x201d }, + { 0x201e, 0x201e }, + { 0x201f, 0x201f }, + { 0x2020, 0x2027 }, + { 0x2028, 0x2028 }, + { 0x2029, 0x2029 }, + { 0x202a, 0x202e }, + { 0x202f, 0x202f }, + { 0x2030, 0x2038 }, + { 0x2039, 0x2039 }, + { 0x203a, 0x203a }, + { 0x203b, 0x203e }, + { 0x203f, 0x2040 }, + { 0x2041, 0x2043 }, + { 0x2044, 0x2044 }, + { 0x2045, 0x2045 }, + { 0x2046, 0x2046 }, + { 0x2047, 0x2069 }, + { 0x206a, 0x206f }, + { 0x2070, 0x2070 }, + { 0x2071, 0x2073 }, + { 0x2074, 0x2079 }, + { 0x207a, 0x207c }, + { 0x207d, 0x207d }, + { 0x207e, 0x207e }, + { 0x207f, 0x207f }, + { 0x2080, 0x2089 }, + { 0x208a, 0x208c }, + { 0x208d, 0x208d }, + { 0x208e, 0x208e }, + { 0x208f, 0x209f }, + { 0x20a0, 0x20ac }, + { 0x20ad, 0x20cf }, + { 0x20d0, 0x20dc }, + { 0x20dd, 0x20e0 }, + { 0x20e1, 0x20e1 }, + { 0x20e2, 0x20ff }, + { 0x2100, 0x2101 }, + { 0x2102, 0x2102 }, + { 0x2103, 0x2106 }, + { 0x2107, 0x2107 }, + { 0x2108, 0x2109 }, + { 0x210a, 0x210a }, + { 0x210b, 0x210d }, + { 0x210e, 0x210f }, + { 0x2110, 0x2112 }, + { 0x2113, 0x2113 }, + { 0x2114, 0x2114 }, + { 0x2115, 0x2115 }, + { 0x2116, 0x2117 }, + { 0x2118, 0x2118 }, + { 0x2119, 0x211d }, + { 0x211e, 0x2123 }, + { 0x2124, 0x2124 }, + { 0x2125, 0x2125 }, + { 0x2126, 0x2126 }, + { 0x2127, 0x2127 }, + { 0x2128, 0x2128 }, + { 0x2129, 0x2129 }, + { 0x212a, 0x212d }, + { 0x212e, 0x212f }, + { 0x2130, 0x2131 }, + { 0x2132, 0x2132 }, + { 0x2133, 0x2133 }, + { 0x2134, 0x2134 }, + { 0x2135, 0x2138 }, + { 0x2139, 0x2152 }, + { 0x2153, 0x215f }, + { 0x2160, 0x2182 }, + { 0x2183, 0x218f }, + { 0x2190, 0x2194 }, + { 0x2195, 0x21d1 }, + { 0x21d2, 0x21d2 }, + { 0x21d3, 0x21d3 }, + { 0x21d4, 0x21d4 }, + { 0x21d5, 0x21ea }, + { 0x21eb, 0x21ff }, + { 0x2200, 0x22f1 }, + { 0x22f2, 0x22ff }, + { 0x2300, 0x2300 }, + { 0x2301, 0x2301 }, + { 0x2302, 0x2307 }, + { 0x2308, 0x230b }, + { 0x230c, 0x231f }, + { 0x2320, 0x2321 }, + { 0x2322, 0x2328 }, + { 0x2329, 0x2329 }, + { 0x232a, 0x232a }, + { 0x232b, 0x237a }, + { 0x237b, 0x23ff }, + { 0x2400, 0x2424 }, + { 0x2425, 0x243f }, + { 0x2440, 0x244a }, + { 0x244b, 0x245f }, + { 0x2460, 0x249b }, + { 0x249c, 0x24e9 }, + { 0x24ea, 0x24ea }, + { 0x24eb, 0x24ff }, + { 0x2500, 0x2595 }, + { 0x2596, 0x259f }, + { 0x25a0, 0x25ef }, + { 0x25f0, 0x25ff }, + { 0x2600, 0x2613 }, + { 0x2614, 0x2619 }, + { 0x261a, 0x266f }, + { 0x2670, 0x2700 }, + { 0x2701, 0x2704 }, + { 0x2705, 0x2705 }, + { 0x2706, 0x2709 }, + { 0x270a, 0x270b }, + { 0x270c, 0x2727 }, + { 0x2728, 0x2728 }, + { 0x2729, 0x274b }, + { 0x274c, 0x274c }, + { 0x274d, 0x274d }, + { 0x274e, 0x274e }, + { 0x274f, 0x2752 }, + { 0x2753, 0x2755 }, + { 0x2756, 0x2756 }, + { 0x2757, 0x2757 }, + { 0x2758, 0x275e }, + { 0x275f, 0x2760 }, + { 0x2761, 0x2767 }, + { 0x2768, 0x2775 }, + { 0x2776, 0x2793 }, + { 0x2794, 0x2794 }, + { 0x2795, 0x2797 }, + { 0x2798, 0x27af }, + { 0x27b0, 0x27b0 }, + { 0x27b1, 0x27be }, + { 0x27bf, 0x2fff }, + { 0x3000, 0x3000 }, + { 0x3001, 0x3003 }, + { 0x3004, 0x3004 }, + { 0x3005, 0x3005 }, + { 0x3006, 0x3006 }, + { 0x3007, 0x3007 }, + { 0x3008, 0x3008 }, + { 0x3009, 0x3009 }, + { 0x300a, 0x300a }, + { 0x300b, 0x300b }, + { 0x300c, 0x300c }, + { 0x300d, 0x300d }, + { 0x300e, 0x300e }, + { 0x300f, 0x300f }, + { 0x3010, 0x3010 }, + { 0x3011, 0x3011 }, + { 0x3012, 0x3013 }, + { 0x3014, 0x3014 }, + { 0x3015, 0x3015 }, + { 0x3016, 0x3016 }, + { 0x3017, 0x3017 }, + { 0x3018, 0x3018 }, + { 0x3019, 0x3019 }, + { 0x301a, 0x301a }, + { 0x301b, 0x301b }, + { 0x301c, 0x301c }, + { 0x301d, 0x301d }, + { 0x301e, 0x301f }, + { 0x3020, 0x3020 }, + { 0x3021, 0x3029 }, + { 0x302a, 0x302f }, + { 0x3030, 0x3030 }, + { 0x3031, 0x3035 }, + { 0x3036, 0x3037 }, + { 0x3038, 0x303e }, + { 0x303f, 0x303f }, + { 0x3040, 0x3040 }, + { 0x3041, 0x3094 }, + { 0x3095, 0x3098 }, + { 0x3099, 0x309a }, + { 0x309b, 0x309c }, + { 0x309d, 0x309e }, + { 0x309f, 0x30a0 }, + { 0x30a1, 0x30fa }, + { 0x30fb, 0x30fb }, + { 0x30fc, 0x30fe }, + { 0x30ff, 0x3104 }, + { 0x3105, 0x312c }, + { 0x312d, 0x3130 }, + { 0x3131, 0x318e }, + { 0x318f, 0x318f }, + { 0x3190, 0x3191 }, + { 0x3192, 0x3195 }, + { 0x3196, 0x319f }, + { 0x31a0, 0x31ff }, + { 0x3200, 0x321c }, + { 0x321d, 0x321f }, + { 0x3220, 0x3229 }, + { 0x322a, 0x3243 }, + { 0x3244, 0x325f }, + { 0x3260, 0x327b }, + { 0x327c, 0x327e }, + { 0x327f, 0x327f }, + { 0x3280, 0x3289 }, + { 0x328a, 0x32b0 }, + { 0x32b1, 0x32bf }, + { 0x32c0, 0x32cb }, + { 0x32cc, 0x32cf }, + { 0x32d0, 0x32fe }, + { 0x32ff, 0x32ff }, + { 0x3300, 0x3376 }, + { 0x3377, 0x337a }, + { 0x337b, 0x33dd }, + { 0x33de, 0x33df }, + { 0x33e0, 0x33fe }, + { 0x33ff, 0x4dff }, + { 0x4e00, 0x9fa5 }, + { 0x9fa6, 0xabff }, + { 0xac00, 0xd7a3 }, + { 0xd7a4, 0xd7ff }, + { 0xd800, 0xdfff }, + { 0xe000, 0xf8ff }, + { 0xf900, 0xfa2d }, + { 0xfa2e, 0xfaff }, + { 0xfb00, 0xfb06 }, + { 0xfb07, 0xfb12 }, + { 0xfb13, 0xfb17 }, + { 0xfb18, 0xfb1d }, + { 0xfb1e, 0xfb1e }, + { 0xfb1f, 0xfb28 }, + { 0xfb29, 0xfb29 }, + { 0xfb2a, 0xfb36 }, + { 0xfb37, 0xfb37 }, + { 0xfb38, 0xfb3c }, + { 0xfb3d, 0xfb3d }, + { 0xfb3e, 0xfb3e }, + { 0xfb3f, 0xfb3f }, + { 0xfb40, 0xfb41 }, + { 0xfb42, 0xfb42 }, + { 0xfb43, 0xfb44 }, + { 0xfb45, 0xfb45 }, + { 0xfb46, 0xfbb1 }, + { 0xfbb2, 0xfbd2 }, + { 0xfbd3, 0xfd3d }, + { 0xfd3e, 0xfd3e }, + { 0xfd3f, 0xfd3f }, + { 0xfd40, 0xfd4f }, + { 0xfd50, 0xfd8f }, + { 0xfd90, 0xfd91 }, + { 0xfd92, 0xfdc7 }, + { 0xfdc8, 0xfdef }, + { 0xfdf0, 0xfdfb }, + { 0xfdfc, 0xfe1f }, + { 0xfe20, 0xfe23 }, + { 0xfe24, 0xfe2f }, + { 0xfe30, 0xfe30 }, + { 0xfe31, 0xfe32 }, + { 0xfe33, 0xfe34 }, + { 0xfe35, 0xfe35 }, + { 0xfe36, 0xfe36 }, + { 0xfe37, 0xfe37 }, + { 0xfe38, 0xfe38 }, + { 0xfe39, 0xfe39 }, + { 0xfe3a, 0xfe3a }, + { 0xfe3b, 0xfe3b }, + { 0xfe3c, 0xfe3c }, + { 0xfe3d, 0xfe3d }, + { 0xfe3e, 0xfe3e }, + { 0xfe3f, 0xfe3f }, + { 0xfe40, 0xfe40 }, + { 0xfe41, 0xfe41 }, + { 0xfe42, 0xfe42 }, + { 0xfe43, 0xfe43 }, + { 0xfe44, 0xfe44 }, + { 0xfe45, 0xfe48 }, + { 0xfe49, 0xfe4c }, + { 0xfe4d, 0xfe4f }, + { 0xfe50, 0xfe52 }, + { 0xfe53, 0xfe53 }, + { 0xfe54, 0xfe57 }, + { 0xfe58, 0xfe58 }, + { 0xfe59, 0xfe59 }, + { 0xfe5a, 0xfe5a }, + { 0xfe5b, 0xfe5b }, + { 0xfe5c, 0xfe5c }, + { 0xfe5d, 0xfe5d }, + { 0xfe5e, 0xfe5e }, + { 0xfe5f, 0xfe61 }, + { 0xfe62, 0xfe62 }, + { 0xfe63, 0xfe63 }, + { 0xfe64, 0xfe66 }, + { 0xfe67, 0xfe67 }, + { 0xfe68, 0xfe68 }, + { 0xfe69, 0xfe69 }, + { 0xfe6a, 0xfe6b }, + { 0xfe6c, 0xfe6f }, + { 0xfe70, 0xfe72 }, + { 0xfe73, 0xfe73 }, + { 0xfe74, 0xfe74 }, + { 0xfe75, 0xfe75 }, + { 0xfe76, 0xfefc }, + { 0xfefd, 0xfefe }, + { 0xfeff, 0xfeff }, + { 0xff00, 0xff00 }, + { 0xff01, 0xff03 }, + { 0xff04, 0xff04 }, + { 0xff05, 0xff07 }, + { 0xff08, 0xff08 }, + { 0xff09, 0xff09 }, + { 0xff0a, 0xff0a }, + { 0xff0b, 0xff0b }, + { 0xff0c, 0xff0c }, + { 0xff0d, 0xff0d }, + { 0xff0e, 0xff0f }, + { 0xff10, 0xff19 }, + { 0xff1a, 0xff1b }, + { 0xff1c, 0xff1e }, + { 0xff1f, 0xff20 }, + { 0xff21, 0xff3a }, + { 0xff3b, 0xff3b }, + { 0xff3c, 0xff3c }, + { 0xff3d, 0xff3d }, + { 0xff3e, 0xff3e }, + { 0xff3f, 0xff3f }, + { 0xff40, 0xff40 }, + { 0xff41, 0xff5a }, + { 0xff5b, 0xff5b }, + { 0xff5c, 0xff5c }, + { 0xff5d, 0xff5d }, + { 0xff5e, 0xff5e }, + { 0xff5f, 0xff60 }, + { 0xff61, 0xff61 }, + { 0xff62, 0xff62 }, + { 0xff63, 0xff63 }, + { 0xff64, 0xff64 }, + { 0xff65, 0xff65 }, + { 0xff66, 0xff6f }, + { 0xff70, 0xff70 }, + { 0xff71, 0xff9d }, + { 0xff9e, 0xff9f }, + { 0xffa0, 0xffbe }, + { 0xffbf, 0xffc1 }, + { 0xffc2, 0xffc7 }, + { 0xffc8, 0xffc9 }, + { 0xffca, 0xffcf }, + { 0xffd0, 0xffd1 }, + { 0xffd2, 0xffd7 }, + { 0xffd8, 0xffd9 }, + { 0xffda, 0xffdc }, + { 0xffdd, 0xffdf }, + { 0xffe0, 0xffe1 }, + { 0xffe2, 0xffe2 }, + { 0xffe3, 0xffe3 }, + { 0xffe4, 0xffe4 }, + { 0xffe5, 0xffe6 }, + { 0xffe7, 0xffe7 }, + { 0xffe8, 0xffec }, + { 0xffed, 0xffee }, + { 0xffef, 0xfffb }, + { 0xfffc, 0xfffd }, + { 0xfffe, 0xffff } + }; + +static const jbyte category_table[] = + { java::lang::Character::CONTROL, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::CONTROL, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::TITLECASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::TITLECASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::TITLECASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::TITLECASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::ENCLOSING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::FORMAT, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::LINE_SEPARATOR, + java::lang::Character::PARAGRAPH_SEPARATOR, + java::lang::Character::FORMAT, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::FORMAT, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::ENCLOSING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::SURROGATE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::FORMAT, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::OTHER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED + }; + +#else /* COMPACT_CHARACTER */ + +#define ROMAN_START 0x2160 +#define ROMAN_END 0x217f + +static const jbyte type_table[] = +{ java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::CONTROL, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::TITLECASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::TITLECASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::TITLECASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::TITLECASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::ENCLOSING_MARK, + java::lang::Character::ENCLOSING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::COMBINING_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::LINE_SEPARATOR, + java::lang::Character::PARAGRAPH_SEPARATOR, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::FORMAT, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::ENCLOSING_MARK, + java::lang::Character::ENCLOSING_MARK, + java::lang::Character::ENCLOSING_MARK, + java::lang::Character::ENCLOSING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::SPACE_SEPARATOR, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::LETTER_NUMBER, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_NUMBER, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::SURROGATE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::PRIVATE_USE, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::NON_SPACING_MARK, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::FORMAT, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DASH_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::DECIMAL_DIGIT_NUMBER, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::UPPERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::LOWERCASE_LETTER, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::START_PUNCTUATION, + java::lang::Character::END_PUNCTUATION, + java::lang::Character::OTHER_PUNCTUATION, + java::lang::Character::CONNECTOR_PUNCTUATION, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::MODIFIER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::OTHER_LETTER, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MODIFIER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::CURRENCY_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::MATH_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::OTHER_SYMBOL, + java::lang::Character::UNASSIGNED, + java::lang::Character::UNASSIGNED + + }; + +static const jshort attribute_table[] = +{ 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, + 4, 5, 6, 7, 8, + 9, 0, 0, 0, 0, + 0, 0, 0, 97, 98, + 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, + 119, 120, 121, 122, 0, + 0, 0, 0, 0, 0, + 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, + 90, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 2, 3, 0, 0, + 0, 0, 0, 1, 0, + 0, -2, -2, -2, 0, + 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, + 244, 245, 246, 0, 248, + 249, 250, 251, 252, 253, + 254, 0, 192, 193, 194, + 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, + 0, 216, 217, 218, 219, + 220, 221, 222, 376, 257, + 256, 259, 258, 261, 260, + 263, 262, 265, 264, 267, + 266, 269, 268, 271, 270, + 273, 272, 275, 274, 277, + 276, 279, 278, 281, 280, + 283, 282, 285, 284, 287, + 286, 289, 288, 291, 290, + 293, 292, 295, 294, 297, + 296, 299, 298, 301, 300, + 303, 302, 105, 73, 307, + 306, 309, 308, 311, 310, + 0, 314, 313, 316, 315, + 318, 317, 320, 319, 322, + 321, 324, 323, 326, 325, + 328, 327, 0, 331, 330, + 333, 332, 335, 334, 337, + 336, 339, 338, 341, 340, + 343, 342, 345, 344, 347, + 346, 349, 348, 351, 350, + 353, 352, 355, 354, 357, + 356, 359, 358, 361, 360, + 363, 362, 365, 364, 367, + 366, 369, 368, 371, 370, + 373, 372, 375, 374, 255, + 378, 377, 380, 379, 382, + 381, 83, 0, 595, 387, + 386, 389, 388, 596, 392, + 391, 598, 599, 396, 395, + 0, 477, 601, 603, 402, + 401, 608, 611, 0, 617, + 616, 409, 408, 0, 0, + 623, 626, 0, 629, 417, + 416, 419, 418, 421, 420, + 640, 424, 423, 643, 0, + 0, 429, 428, 648, 432, + 431, 650, 651, 436, 435, + 438, 437, 658, 441, 440, + 0, 0, 445, 444, 0, + 0, 0, 0, 0, 0, + 454, 0, 452, 457, 0, + 455, 460, 0, 458, 462, + 461, 464, 463, 466, 465, + 468, 467, 470, 469, 472, + 471, 474, 473, 476, 475, + 398, 479, 478, 481, 480, + 483, 482, 485, 484, 487, + 486, 489, 488, 491, 490, + 493, 492, 495, 494, 0, + 499, 0, 497, 501, 500, + 0, 0, 0, 0, 507, + 506, 509, 508, 511, 510, + 513, 512, 515, 514, 517, + 516, 519, 518, 521, 520, + 523, 522, 525, 524, 527, + 526, 529, 528, 531, 530, + 533, 532, 535, 534, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 385, 390, + 0, 393, 394, 0, 399, + 0, 400, 0, 0, 0, + 0, 403, 0, 0, 404, + 0, 0, 0, 0, 407, + 406, 0, 0, 0, 0, + 0, 412, 0, 0, 413, + 0, 0, 415, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 422, 0, + 0, 425, 0, 0, 0, + 0, 430, 0, 433, 434, + 0, 0, 0, 0, 0, + 0, 439, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 921, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 940, 0, 941, 942, 943, + 0, 972, 0, 973, 974, + 0, 945, 946, 947, 948, + 949, 950, 951, 952, 953, + 954, 955, 956, 957, 958, + 959, 960, 961, 0, 963, + 964, 965, 966, 967, 968, + 969, 970, 971, 902, 904, + 905, 906, 0, 913, 914, + 915, 916, 917, 918, 919, + 920, 921, 922, 923, 924, + 925, 926, 927, 928, 929, + 931, 931, 932, 933, 934, + 935, 936, 937, 938, 939, + 908, 910, 911, 0, 914, + 920, 0, 0, 0, 934, + 928, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 995, 994, 997, + 996, 999, 998, 1001, 1000, + 1003, 1002, 1005, 1004, 1007, + 1006, 922, 929, 931, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 1105, 1106, + 1107, 1108, 1109, 1110, 1111, + 1112, 1113, 1114, 1115, 1116, + 0, 1118, 1119, 1072, 1073, + 1074, 1075, 1076, 1077, 1078, + 1079, 1080, 1081, 1082, 1083, + 1084, 1085, 1086, 1087, 1088, + 1089, 1090, 1091, 1092, 1093, + 1094, 1095, 1096, 1097, 1098, + 1099, 1100, 1101, 1102, 1103, + 1040, 1041, 1042, 1043, 1044, + 1045, 1046, 1047, 1048, 1049, + 1050, 1051, 1052, 1053, 1054, + 1055, 1056, 1057, 1058, 1059, + 1060, 1061, 1062, 1063, 1064, + 1065, 1066, 1067, 1068, 1069, + 1070, 1071, 0, 1025, 1026, + 1027, 1028, 1029, 1030, 1031, + 1032, 1033, 1034, 1035, 1036, + 0, 1038, 1039, 1121, 1120, + 1123, 1122, 1125, 1124, 1127, + 1126, 1129, 1128, 1131, 1130, + 1133, 1132, 1135, 1134, 1137, + 1136, 1139, 1138, 1141, 1140, + 1143, 1142, 1145, 1144, 1147, + 1146, 1149, 1148, 1151, 1150, + 1153, 1152, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1169, 1168, 1171, 1170, + 1173, 1172, 1175, 1174, 1177, + 1176, 1179, 1178, 1181, 1180, + 1183, 1182, 1185, 1184, 1187, + 1186, 1189, 1188, 1191, 1190, + 1193, 1192, 1195, 1194, 1197, + 1196, 1199, 1198, 1201, 1200, + 1203, 1202, 1205, 1204, 1207, + 1206, 1209, 1208, 1211, 1210, + 1213, 1212, 1215, 1214, 0, + 1218, 1217, 1220, 1219, 0, + 0, 1224, 1223, 0, 0, + 1228, 1227, 0, 0, 0, + 1233, 1232, 1235, 1234, 1237, + 1236, 1239, 1238, 1241, 1240, + 1243, 1242, 1245, 1244, 1247, + 1246, 1249, 1248, 1251, 1250, + 1253, 1252, 1255, 1254, 1257, + 1256, 1259, 1258, 0, 0, + 1263, 1262, 1265, 1264, 1267, + 1266, 1269, 1268, 0, 0, + 1273, 1272, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1377, 1378, 1379, + 1380, 1381, 1382, 1383, 1384, + 1385, 1386, 1387, 1388, 1389, + 1390, 1391, 1392, 1393, 1394, + 1395, 1396, 1397, 1398, 1399, + 1400, 1401, 1402, 1403, 1404, + 1405, 1406, 1407, 1408, 1409, + 1410, 1411, 1412, 1413, 1414, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1329, 1330, 1331, 1332, 1333, + 1334, 1335, 1336, 1337, 1338, + 1339, 1340, 1341, 1342, 1343, + 1344, 1345, 1346, 1347, 1348, + 1349, 1350, 1351, 1352, 1353, + 1354, 1355, 1356, 1357, 1358, + 1359, 1360, 1361, 1362, 1363, + 1364, 1365, 1366, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 2, + 3, 4, 5, 6, 7, + 8, 9, 0, 0, 0, + 0, 1, 2, 3, 4, + -2, 16, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, + 2, 3, 4, 5, 6, + 7, 8, 9, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, + 4, 5, 6, 7, 8, + 9, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, + 100, 1000, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 2, + 3, 4, 5, 6, 7, + 8, 9, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, + 2, 3, 4, 5, 6, + 7, 8, 9, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 1, 2, + 3, 4, 5, 6, 7, + 8, 9, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4304, + 4305, 4306, 4307, 4308, 4309, + 4310, 4311, 4312, 4313, 4314, + 4315, 4316, 4317, 4318, 4319, + 4320, 4321, 4322, 4323, 4324, + 4325, 4326, 4327, 4328, 4329, + 4330, 4331, 4332, 4333, 4334, + 4335, 4336, 4337, 4338, 4339, + 4340, 4341, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 7681, 7680, + 7683, 7682, 7685, 7684, 7687, + 7686, 7689, 7688, 7691, 7690, + 7693, 7692, 7695, 7694, 7697, + 7696, 7699, 7698, 7701, 7700, + 7703, 7702, 7705, 7704, 7707, + 7706, 7709, 7708, 7711, 7710, + 7713, 7712, 7715, 7714, 7717, + 7716, 7719, 7718, 7721, 7720, + 7723, 7722, 7725, 7724, 7727, + 7726, 7729, 7728, 7731, 7730, + 7733, 7732, 7735, 7734, 7737, + 7736, 7739, 7738, 7741, 7740, + 7743, 7742, 7745, 7744, 7747, + 7746, 7749, 7748, 7751, 7750, + 7753, 7752, 7755, 7754, 7757, + 7756, 7759, 7758, 7761, 7760, + 7763, 7762, 7765, 7764, 7767, + 7766, 7769, 7768, 7771, 7770, + 7773, 7772, 7775, 7774, 7777, + 7776, 7779, 7778, 7781, 7780, + 7783, 7782, 7785, 7784, 7787, + 7786, 7789, 7788, 7791, 7790, + 7793, 7792, 7795, 7794, 7797, + 7796, 7799, 7798, 7801, 7800, + 7803, 7802, 7805, 7804, 7807, + 7806, 7809, 7808, 7811, 7810, + 7813, 7812, 7815, 7814, 7817, + 7816, 7819, 7818, 7821, 7820, + 7823, 7822, 7825, 7824, 7827, + 7826, 7829, 7828, 0, 0, + 0, 0, 0, 7776, 0, + 0, 0, 0, 7841, 7840, + 7843, 7842, 7845, 7844, 7847, + 7846, 7849, 7848, 7851, 7850, + 7853, 7852, 7855, 7854, 7857, + 7856, 7859, 7858, 7861, 7860, + 7863, 7862, 7865, 7864, 7867, + 7866, 7869, 7868, 7871, 7870, + 7873, 7872, 7875, 7874, 7877, + 7876, 7879, 7878, 7881, 7880, + 7883, 7882, 7885, 7884, 7887, + 7886, 7889, 7888, 7891, 7890, + 7893, 7892, 7895, 7894, 7897, + 7896, 7899, 7898, 7901, 7900, + 7903, 7902, 7905, 7904, 7907, + 7906, 7909, 7908, 7911, 7910, + 7913, 7912, 7915, 7914, 7917, + 7916, 7919, 7918, 7921, 7920, + 7923, 7922, 7925, 7924, 7927, + 7926, 7929, 7928, 0, 0, + 0, 0, 0, 0, 7944, + 7945, 7946, 7947, 7948, 7949, + 7950, 7951, 7936, 7937, 7938, + 7939, 7940, 7941, 7942, 7943, + 7960, 7961, 7962, 7963, 7964, + 7965, 0, 0, 7952, 7953, + 7954, 7955, 7956, 7957, 0, + 0, 7976, 7977, 7978, 7979, + 7980, 7981, 7982, 7983, 7968, + 7969, 7970, 7971, 7972, 7973, + 7974, 7975, 7992, 7993, 7994, + 7995, 7996, 7997, 7998, 7999, + 7984, 7985, 7986, 7987, 7988, + 7989, 7990, 7991, 8008, 8009, + 8010, 8011, 8012, 8013, 0, + 0, 8000, 8001, 8002, 8003, + 8004, 8005, 0, 0, 0, + 8025, 0, 8027, 0, 8029, + 0, 8031, 0, 8017, 0, + 8019, 0, 8021, 0, 8023, + 8040, 8041, 8042, 8043, 8044, + 8045, 8046, 8047, 8032, 8033, + 8034, 8035, 8036, 8037, 8038, + 8039, 8122, 8123, 8136, 8137, + 8138, 8139, 8154, 8155, 8184, + 8185, 8170, 8171, 8186, 8187, + 0, 0, 8072, 8073, 8074, + 8075, 8076, 8077, 8078, 8079, + 8064, 8065, 8066, 8067, 8068, + 8069, 8070, 8071, 8088, 8089, + 8090, 8091, 8092, 8093, 8094, + 8095, 8080, 8081, 8082, 8083, + 8084, 8085, 8086, 8087, 8104, + 8105, 8106, 8107, 8108, 8109, + 8110, 8111, 8096, 8097, 8098, + 8099, 8100, 8101, 8102, 8103, + 8120, 8121, 0, 8124, 0, + 0, 0, 0, 8112, 8113, + 8048, 8049, 8115, 0, 921, + 0, 0, 0, 0, 8140, + 0, 0, 0, 0, 8050, + 8051, 8052, 8053, 8131, 0, + 0, 0, 8152, 8153, 0, + 0, 0, 0, 0, 0, + 8144, 8145, 8054, 8055, 0, + 0, 0, 0, 8168, 8169, + 0, 0, 0, 8172, 0, + 0, 8160, 8161, 8058, 8059, + 8165, 0, 0, 0, 0, + 0, 0, 8188, 0, 0, + 0, 0, 8056, 8057, 8060, + 8061, 8179, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 4, 5, 6, 7, + 8, 9, 0, 0, 0, + 0, 0, 0, 0, 1, + 2, 3, 4, 5, 6, + 7, 8, 9, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, -2, + -2, -2, -2, -2, -2, + -2, -2, -2, -2, -2, + -2, 1, 8560, 8561, 8562, + 8563, 8564, 8565, 8566, 8567, + 8568, 8569, 8570, 8571, 8572, + 8573, 8574, 8575, 8544, 8545, + 8546, 8547, 8548, 8549, 8550, + 8551, 8552, 8553, 8554, 8555, + 8556, 8557, 8558, 8559, 1000, + 5000, 10000, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 9424, 9425, 9426, 9427, + 9428, 9429, 9430, 9431, 9432, + 9433, 9434, 9435, 9436, 9437, + 9438, 9439, 9440, 9441, 9442, + 9443, 9444, 9445, 9446, 9447, + 9448, 9449, 9398, 9399, 9400, + 9401, 9402, 9403, 9404, 9405, + 9406, 9407, 9408, 9409, 9410, + 9411, 9412, 9413, 9414, 9415, + 9416, 9417, 9418, 9419, 9420, + 9421, 9422, 9423, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, + 2, 3, 4, 5, 6, + 7, 8, 9, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 1, 2, 3, 4, + 5, 6, 7, 8, 9, + 10, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 1, 2, 3, 4, 5, + 6, 7, 8, 9, 0, + 0, 0, 0, 0, 0, + 0, 65345, 65346, 65347, 65348, + 65349, 65350, 65351, 65352, 65353, + 65354, 65355, 65356, 65357, 65358, + 65359, 65360, 65361, 65362, 65363, + 65364, 65365, 65366, 65367, 65368, + 65369, 65370, 0, 0, 0, + 0, 0, 0, 65313, 65314, + 65315, 65316, 65317, 65318, 65319, + 65320, 65321, 65322, 65323, 65324, + 65325, 65326, 65327, 65328, 65329, + 65330, 65331, 65332, 65333, 65334, + 65335, 65336, 65337, 65338, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0 + }; + +static const jshort secondary_attribute_table[] = +{ 1, 2, 3, + 4, 5, 6, 7, 8, + 9, 10, 11, 12, 50, + 100, 500, 1000, 1, 2, + 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, + 50, 100, 500, 1000 + }; + +#endif /* COMPACT_CHARACTER */ + +#endif /* __JAVA_CHARTABLES_H__ */ diff --git a/libjava/include/java-field.h b/libjava/include/java-field.h new file mode 100644 index 00000000000..b4529fca30a --- /dev/null +++ b/libjava/include/java-field.h @@ -0,0 +1,158 @@ +// java-field.h - Header file for fieldID instances. -*- c++ -*- + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVA_FIELD_H__ +#define __JAVA_FIELD_H__ + +#include +#include + +#define _Jv_FIELD_UNRESOLVED_FLAG 0x8000 +#define _Jv_FIELD_CONSTANT_VALUE 0x4000 + +struct _Jv_Field +{ +#ifndef COMPACT_FIELDS + struct _Jv_Utf8Const* name; +#endif + + /* The type of the field, if isResolved(). + If !isResolved(): The fields's signature as a (Utf8Const*). */ + jclass type; + + _Jv_ushort flags; + +#ifdef COMPACT_FIELDS + short nameIndex; /* ofsfet in class's name table */ +#else + _Jv_ushort bsize; /* not really needed ... */ +#endif + + union { + int boffset; /* offset in bytes for instance field */ + void* addr; /* address of static field */ + } u; + +#ifdef __cplusplus + jboolean isResolved () + { return ! (flags & _Jv_FIELD_UNRESOLVED_FLAG); } + + public: + + int getOffset () { return u.boffset; } + + jobject getObjectField (jobject obj) + { return *(jobject *)((char *)obj + getOffset ()); } + + jfieldID getNextInstanceField () { return this + 1; } + + jboolean isRef () { return ! isResolved () || ! type->isPrimitive (); } + + // FIXME - may need to mask off internal flags. + int getModifiers() { return flags; } + +#ifdef COMPACT_FIELDS + _Jv_Utf8Const * getNameUtf8Const (jclass cls) + { return clas->fieldNames + nameIndex; } +#else + _Jv_Utf8Const * getNameUtf8Const (jclass) { return name; } +#endif +#endif +}; + +#ifdef __cplusplus +inline jbyte +_Jv_GetStaticByteField (jclass, _Jv_Field* field) +{ + return * (jbyte *) field->u.addr; +} + +inline jshort +_Jv_GetStaticShortField (jclass, _Jv_Field* field) +{ + return * (jshort *) field->u.addr; +} + +inline jint +_Jv_GetStaticIntField (jclass, _Jv_Field* field) +{ + return * (jint *) field->u.addr; +} + +inline jlong +_Jv_GetStaticLongField (jclass, _Jv_Field* field) +{ + return * (jlong *) field->u.addr; +} + +inline jobject +_Jv_GetObjectField (jobject obj, _Jv_Field* field) +{ + return field->getObjectField (obj); +} + +inline jbyte +_Jv_GetByteField (jobject obj, _Jv_Field* field) +{ + return * (jbyte *) ((char*) obj + field->getOffset ()); +} + +inline jshort +_Jv_GetShortField (jobject obj, _Jv_Field* field) +{ + return * (jshort *) ((char*) obj + field->getOffset ()); +} +inline jint +_Jv_GetIntField (jobject obj, _Jv_Field* field) +{ + return * (jint *) ((char*) obj + field->getOffset ()); +} +inline jlong +_Jv_GetLongField (jobject obj, _Jv_Field* field) +{ + return * (jlong *) ((char*) obj + field->getOffset ()); +} + +extern inline jfieldID +_Jv_FromReflectedField (java::lang::reflect::Field *field) +{ + return (jfieldID) ((char *) field->declaringClass->fields + field->offset); +} + + +#ifdef __JAVA_CNI_H__ +extern inline jfieldID +JvGetFirstInstanceField (jclass klass) +{ + return &(klass->fields[klass->static_field_count]); +} + +extern inline jint +JvNumInstanceFields (jclass klass) +{ + return klass->field_count - klass->static_field_count; +} + +extern inline jboolean +JvFieldIsRef (jfieldID field) +{ + return field->isRef (); +} + +extern inline jobject +JvGetObjectField (jobject obj, _Jv_Field* field) +{ + return _Jv_GetObjectField (obj, field); +} +#endif /* defined (__JAVA_CNI_H__) */ + +#endif + +#endif /* __JAVA_FIELD_H */ diff --git a/libjava/include/java-method.h b/libjava/include/java-method.h new file mode 100644 index 00000000000..1bda4719c2b --- /dev/null +++ b/libjava/include/java-method.h @@ -0,0 +1,16 @@ +// java-method.h - Header file for methodID instances. -*- c++ -*- + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +extern inline jmethodID +_Jv_FromReflectedMethod(java::lang::reflect::Method *method) +{ + return (jmethodID) + ((char *) method->declaringClass->methods + method->offset); +} diff --git a/libjava/include/javaprims.h b/libjava/include/javaprims.h new file mode 100644 index 00000000000..83c2cf9faeb --- /dev/null +++ b/libjava/include/javaprims.h @@ -0,0 +1,262 @@ +// javaprims.h - Main external header file for libgcj. -*- c++ -*- + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVAPRIMS_H__ +#define __JAVAPRIMS_H__ + +// To force selection of correct types that will mangle consistently +// across platforms. +extern "Java" +{ + typedef __java_byte jbyte; + typedef __java_short jshort; + typedef __java_int jint; + typedef __java_long jlong; + typedef __java_float jfloat; + typedef __java_double jdouble; + typedef __java_char jchar; + typedef __java_boolean jboolean; + typedef jint jsize; + + // The following class declarations are automatically generated by + // the `classes.pl' script. + namespace java + { + namespace io + { + class BufferedInputStream; + class BufferedOutputStream; + class BufferedReader; + class BufferedWriter; + class ByteArrayInputStream; + class ByteArrayOutputStream; + class CharArrayReader; + class CharArrayWriter; + class CharConversionException; + class DataInput; + class DataInputStream; + class DataOutput; + class DataOutputStream; + class EOFException; + class File; + class FileDescriptor; + class FileInputStream; + class FileNotFoundException; + class FileOutputStream; + class FileReader; + class FileWriter; + class FilenameFilter; + class FilterInputStream; + class FilterOutputStream; + class FilterReader; + class FilterWriter; + class IOException; + class InputStream; + class InputStreamReader; + class InterruptedIOException; + class LineNumberInputStream; + class LineNumberReader; + class OutputStream; + class OutputStreamWriter; + class PipedInputStream; + class PipedOutputStream; + class PipedReader; + class PipedWriter; + class PrintStream; + class PrintWriter; + class PushbackInputStream; + class PushbackReader; + class RandomAccessFile; + class Reader; + class SequenceInputStream; + class Serializable; + class StreamTokenizer; + class StringBufferInputStream; + class StringReader; + class StringWriter; + class SyncFailedException; + class UTFDataFormatException; + class UnsupportedEncodingException; + class Writer; + }; + + namespace lang + { + class AbstractMethodError; + class ArithmeticException; + class ArrayIndexOutOfBoundsException; + class ArrayStoreException; + class Boolean; + class Byte; + class Character; + class Class; + class ClassCastException; + class ClassCircularityError; + class ClassFormatError; + class ClassLoader; + class ClassNotFoundException; + class CloneNotSupportedException; + class Cloneable; + class Comparable; + class Compiler; + class Double; + class Error; + class Exception; + class ExceptionInInitializerError; + class FirstThread; + class Float; + class IllegalAccessError; + class IllegalAccessException; + class IllegalArgumentException; + class IllegalMonitorStateException; + class IllegalStateException; + class IllegalThreadStateException; + class IncompatibleClassChangeError; + class IndexOutOfBoundsException; + class InstantiationError; + class InstantiationException; + class Integer; + class InternalError; + class InterruptedException; + class LinkageError; + class Long; + class Math; + class NegativeArraySizeException; + class NoClassDefFoundError; + class NoSuchFieldError; + class NoSuchFieldException; + class NoSuchMethodError; + class NoSuchMethodException; + class NullPointerException; + class Number; + class NumberFormatException; + class Object; + class OutOfMemoryError; + class Process; + class Runnable; + class Runtime; + class RuntimeException; + class SecurityException; + class SecurityManager; + class Short; + class StackOverflowError; + class String; + class StringBuffer; + class StringIndexOutOfBoundsException; + class System; + class Thread; + class ThreadDeath; + class ThreadGroup; + class Throwable; + class UnknownError; + class UnsatisfiedLinkError; + class UnsupportedOperationException; + class VerifyError; + class VirtualMachineError; + class Void; + + namespace reflect + { + class AccessibleObject; + class Array; + class Constructor; + class Field; + class InvocationTargetException; + class Member; + class Method; + class Modifier; + }; + }; + + namespace util + { + class BitSet; + class Calendar; + class ConcurrentModificationException; + class Date; + class Dictionary; + class EmptyStackException; + class Enumeration; + class EventListener; + class EventObject; + class GregorianCalendar; + class Hashtable; + class HashtableEntry; + class HashtableEnumeration; + class ListResourceBundle; + class Locale; + class MissingResourceException; + class NoSuchElementException; + class Observable; + class Observer; + class Properties; + class Random; + class ResourceBundle; + class SimpleTimeZone; + class Stack; + class StringTokenizer; + class TimeZone; + class TooManyListenersException; + class Vector; + class VectorEnumeration; + + namespace zip + { + class Adler32; + class CRC32; + class Checksum; + class Deflater; + class DeflaterOutputStream; + class ZipConstants; + class ZipEntry; + class ZipEnumeration; + class ZipException; + class ZipFile; + class ZipOutputStream; + }; + }; + }; +}; + +typedef struct java::lang::Object* jobject; +typedef class java::lang::Class* jclass; +typedef class java::lang::Throwable* jthrowable; +typedef class java::lang::String* jstring; +struct _Jv_JNIEnv; + +typedef struct _Jv_Field *jfieldID; +typedef struct _Jv_Method *jmethodID; + +extern "C" jobject _Jv_AllocObject (jclass, jint); +extern "C" jboolean _Jv_IsInstanceOf(jobject, jclass); +extern "C" jstring _Jv_AllocString(jsize); +extern "C" jstring _Jv_NewString (const jchar*, jsize); +extern "C" jchar* _Jv_GetStringChars (jstring str); +extern "C" jint _Jv_MonitorEnter (jobject); +extern "C" jint _Jv_MonitorExit (jobject); +extern "C" jstring _Jv_NewStringLatin1(const char*, jsize); +extern "C" jsize _Jv_GetStringUTFLength (jstring); +extern "C" jsize _Jv_GetStringUTFRegion (jstring, jsize, jsize, char *); + +extern "C" void _Jv_Throw (void *) __attribute__ ((__noreturn__)); +extern "C" void* _Jv_Malloc (jsize); +extern "C" void _Jv_Free (void*); + +typedef unsigned short _Jv_ushort __attribute__((__mode__(__HI__))); +typedef unsigned int _Jv_uint __attribute__((__mode__(__SI__))); + +struct _Jv_Utf8Const +{ + _Jv_ushort hash; + _Jv_ushort length; /* In bytes, of data portion, without final '\0'. */ + char data[1]; /* In Utf8 format, with final '\0'. */ +}; + +#endif /* __JAVAPRIMS_H__ */ diff --git a/libjava/include/jni.h b/libjava/include/jni.h new file mode 100644 index 00000000000..bf7b015cdca --- /dev/null +++ b/libjava/include/jni.h @@ -0,0 +1,302 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVA_JNI_H__ +#define __JAVA_JNI_H__ + +#ifdef __GNUC__ +# define __need___va_list +# include +# define _Jv_va_list __gnuc_va_list +#else +# include +# define _Jv_va_list va_list +#endif + +#ifdef __cplusplus + +// This is wrong, because it pollutes the name-space too much! +#include + +typedef struct _Jv_JNIEnv JNIEnv; +#else + +typedef int jbyte __attribute__((__mode__(__QI__))); +typedef int jshort __attribute__((__mode__(__HI__))); +typedef int jint __attribute__((__mode__(__SI__))); +typedef int jlong __attribute__((__mode__(__DI__))); +typedef bool jboolean __attribute__((__mode__(__QI__))); +typedef unsigned short jchar __attribute__((__mode__(__HI__))); +typedef float jfloat; +typedef double jdouble; +typedef jint jsize; + +typedef const struct JNINativeInterface *JNIEnv; +#endif + +typedef union jvalue +{ + jboolean z; + jbyte b; + jchar c; + jshort s; + jint i; + jlong j; + jfloat f; + jdouble d; + jobject l; +} jvalue; + +typedef void * (*_Jv_func)(...); + +struct JNINativeInterface +{ + _Jv_func reserved0; + _Jv_func reserved1; + _Jv_func reserved2; + _Jv_func reserved3; + _Jv_func GetVersion; + _Jv_func DefineClass; + _Jv_func FindClass; + _Jv_func reserved4; + _Jv_func reserved5; + _Jv_func reserved6; + jclass (*GetSuperclass) (JNIEnv*, jclass); + jboolean (*IsAssignableFrom) (JNIEnv*, jclass, jclass); + _Jv_func reserved7; + jint (*Throw) (JNIEnv*, jthrowable); + _Jv_func ThrowNew; + _Jv_func ExceptionOccurred; + _Jv_func ExceptionDescribe; + _Jv_func ExceptionClear; + _Jv_func FatalError; + _Jv_func reserved8; + _Jv_func reserved9; + _Jv_func NewGlobalRef; + _Jv_func DeleteGlobalRef; + _Jv_func DeleteLocalRef; + _Jv_func IsSameObject; + _Jv_func reserved10; + _Jv_func reserved11; + _Jv_func AllocObject; + _Jv_func NewObject; + _Jv_func NewObjectV; + _Jv_func NewObjectA; + _Jv_func GetObjectClass; + _Jv_func IsInstanceOf; + _Jv_func GetMethodID; + _Jv_func CallObjectMethod; + _Jv_func CallObjectMethodV; + _Jv_func CallObjectMethodA; + _Jv_func CallBooleanMethod; + _Jv_func CallBooleanMethodV; + _Jv_func CallBooleanMethodA; + _Jv_func CallByteMethod; + _Jv_func CallByteMethodV; + _Jv_func CallByteMethodA; + _Jv_func CallCharMethod; + _Jv_func CallCharMethodV; + _Jv_func CallCharMethodA; + _Jv_func CallShortMethod; + _Jv_func CallShortMethodV; + _Jv_func CallShortMethodA; + _Jv_func CallIntMethod; + _Jv_func CallIntMethodV; + _Jv_func CallIntMethodA; + _Jv_func CallLongMethod; + _Jv_func CallLongMethodV; + _Jv_func CallLongMethodA; + _Jv_func CallFloatMethod; + _Jv_func CallFloatMethodV; + _Jv_func CallFloatMethodA; + _Jv_func CallDoubleMethod; + _Jv_func CallDoubleMethodV; + _Jv_func CallDoubleMethodA; + _Jv_func CallVoidMethod; + _Jv_func CallVoidMethodV; + _Jv_func CallVoidMethodA; + _Jv_func CallNonvirtualObjectMethod; + _Jv_func CallNonvirtualObjectMethodV; + _Jv_func CallNonvirtualObjectMethodA; + jboolean (*CallNonvirtualBooleanMethod) (JNIEnv*, jobject, jclass, jmethodID, ...); + jboolean (*CallNonvirtualBooleanMethodV) (JNIEnv*, jobject, jclass, jmethodID, _Jv_va_list); + jboolean (*CallNonvirtualBooleanMethodA) (JNIEnv*, jobject, jclass, jmethodID, jvalue*); + _Jv_func CallNonvirtualByteMethod; + _Jv_func CallNonvirtualByteMethodV; + _Jv_func CallNonvirtualByteMethodA; + _Jv_func CallNonvirtualCharMethod; + _Jv_func CallNonvirtualCharMethodV; + _Jv_func CallNonvirtualCharMethodA; + _Jv_func CallNonvirtualShortMethod; + _Jv_func CallNonvirtualShortMethodV; + _Jv_func CallNonvirtualShortMethodA; + _Jv_func CallNonvirtualIntMethod; + _Jv_func CallNonvirtualIntMethodV; + _Jv_func CallNonvirtualIntMethodA; + _Jv_func CallNonvirtualLongMethod; + _Jv_func CallNonvirtualLongMethodV; + _Jv_func CallNonvirtualLongMethodA; + _Jv_func CallNonvirtualFloatMethod; + _Jv_func CallNonvirtualFloatMethodV; + _Jv_func CallNonvirtualFloatMethodA; + _Jv_func CallNonvirtualDoubleMethod; + jdouble (*CallNonvirtualDoubleMethodV) (JNIEnv*, jobject, jclass, jmethodID, _Jv_va_list); + _Jv_func CallNonvirtualDoubleMethodA; + _Jv_func CallNonvirtualVoidMethod; + _Jv_func CallNonvirtualVoidMethodV; + _Jv_func CallNonvirtualVoidMethodA; + _Jv_func GetFieldID; + jobject (*GetObjectField) (JNIEnv*, jobject, jfieldID); + jboolean (*GetBooleanField) (JNIEnv*, jobject, jfieldID); + jbyte (*GetByteField) (JNIEnv*, jobject, jfieldID); + jchar (*GetCharField) (JNIEnv*, jobject, jfieldID); + jshort (*GetShortField) (JNIEnv*, jobject, jfieldID); + jint (*GetIntField) (JNIEnv*, jobject, jfieldID); + jlong (*GetLongField) (JNIEnv*, jobject, jfieldID); + jfloat (*GetFloatField) (JNIEnv*, jobject, jfieldID); + jdouble (*GetDoubleField) (JNIEnv*, jobject, jfieldID); + _Jv_func SetObjectField; + _Jv_func SetBooleanField; + _Jv_func SetByteField; + _Jv_func SetCharField; + _Jv_func SetShortField; + _Jv_func SetIntField; + _Jv_func SetLongField; + _Jv_func SetFloatField; + _Jv_func SetDoubleField; + _Jv_func GetStaticMethodID; + _Jv_func CallStaticObjectMethod; + _Jv_func CallStaticObjectMethodV; + _Jv_func CallStaticObjectMethodA; + _Jv_func CallStaticBooleanMethod; + _Jv_func CallStaticBooleanMethodV; + _Jv_func CallStaticBooleanMethodA; + _Jv_func CallStaticByteMethod; + _Jv_func CallStaticByteMethodV; + _Jv_func CallStaticByteMethodA; + _Jv_func CallStaticCharMethod; + _Jv_func CallStaticCharMethodV; + _Jv_func CallStaticCharMethodA; + _Jv_func CallStaticShortMethod; + _Jv_func CallStaticShortMethodV; + _Jv_func CallStaticShortMethodA; + _Jv_func CallStaticIntMethod; + _Jv_func CallStaticIntMethodV; + _Jv_func CallStaticIntMethodA; + _Jv_func CallStaticLongMethod; + _Jv_func CallStaticLongMethodV; + _Jv_func CallStaticLongMethodA; + _Jv_func CallStaticFloatMethod; + _Jv_func CallStaticFloatMethodV; + _Jv_func CallStaticFloatMethodA; + _Jv_func CallStaticDoubleMethod; + _Jv_func CallStaticDoubleMethodV; + _Jv_func CallStaticDoubleMethodA; + _Jv_func CallStaticVoidMethod; + _Jv_func CallStaticVoidMethodV; + _Jv_func CallStaticVoidMethodA; + _Jv_func GetStaticFieldID; + _Jv_func GetStaticObjectField; + _Jv_func GetStaticBooleanField; + _Jv_func GetStaticByteField; + _Jv_func GetStaticCharField; + _Jv_func GetStaticShortField; + _Jv_func GetStaticIntField; + _Jv_func GetStaticLongField; + _Jv_func GetStaticFloatField; + _Jv_func GetStaticDoubleField; + _Jv_func SetStaticObjectField; + _Jv_func SetStaticBooleanField; + _Jv_func SetStaticByteField; + _Jv_func SetStaticCharField; + _Jv_func SetStaticShortField; + _Jv_func SetStaticIntField; + _Jv_func SetStaticLongField; + _Jv_func SetStaticFloatField; + _Jv_func SetStaticDoubleField; + _Jv_func NewString; + jint (*GetStringLength) (JNIEnv*, jstring); + _Jv_func GetStringChars; + _Jv_func ReleaseStringChars; + _Jv_func NewStringUTF; + _Jv_func GetStringUTFLength; + _Jv_func GetStringUTFChars; + _Jv_func ReleaseStringUTFChars; + _Jv_func GetArrayLength; + _Jv_func NewObjectArray; + _Jv_func GetObjectArrayElement; + _Jv_func SetObjectArrayElement; + _Jv_func NewBooleanArray; + _Jv_func NewByteArray; + _Jv_func NewCharArray; + _Jv_func NewShortArray; + _Jv_func NewIntArray; + _Jv_func NewLongArray; + _Jv_func NewFloatArray; + _Jv_func NewDoubleArray; + _Jv_func GetBooleanArrayElements; + _Jv_func GetByteArrayElements; + _Jv_func GetCharArrayElements; + _Jv_func GetShortArrayElements; + _Jv_func GetIntArrayElements; + _Jv_func GetLongArrayElements; + _Jv_func GetFloatArrayElements; + _Jv_func GetDoubleArrayElements; + _Jv_func ReleaseBooleanArrayElements; + _Jv_func ReleaseByteArrayElements; + _Jv_func ReleaseCharArrayElements; + _Jv_func ReleaseShortArrayElements; + _Jv_func ReleaseIntArrayElements; + _Jv_func ReleaseLongArrayElements; + _Jv_func ReleaseFloatArrayElements; + _Jv_func ReleaseDoubleArrayElements; + _Jv_func GetBooleanArrayRegion; + _Jv_func GetByteArrayRegion; + _Jv_func GetCharArrayRegion; + _Jv_func GetShortArrayRegion; + _Jv_func GetIntArrayRegion; + _Jv_func GetLongArrayRegion; + _Jv_func GetFloatArrayRegion; + _Jv_func GetDoubleArrayRegion; + _Jv_func SetBooleanArrayRegion; + _Jv_func SetByteArrayRegion; + _Jv_func SetCharArrayRegion; + _Jv_func SetShortArrayRegion; + _Jv_func SetIntArrayRegion; + _Jv_func SetLongArrayRegion; + _Jv_func SetFloatArrayRegion; + _Jv_func SetDoubleArrayRegion; + _Jv_func RegisterNatives; + _Jv_func UnregisterNatives; + _Jv_func MonitorEnter; + _Jv_func MonitorExit; + _Jv_func GetJavaVM; +}; + +#ifdef __cplusplus + +struct _Jv_JNIEnv +{ + struct JNINativeInterface *p; + + jclass GetSuperclass (jclass cl); + jsize GetStringLength (jstring str); + +}; + +extern inline jclass +_Jv_JNIEnv::GetSuperclass (jclass cl) +{ return p->GetSuperclass (this, cl); } + +extern inline jsize +_Jv_JNIEnv::GetStringLength (jstring str) +{ return p->GetStringLength (this, str); } + +#endif + +#endif /* __JAVA_JNI_H__ */ diff --git a/libjava/include/jvm.h b/libjava/include/jvm.h new file mode 100644 index 00000000000..f928d7178b6 --- /dev/null +++ b/libjava/include/jvm.h @@ -0,0 +1,101 @@ +// jvm.h - Header file for private implementation information. -*- c++ -*- + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVA_JVM_H__ +#define __JAVA_JVM_H__ + +#include +#include + +/* Structure of the virtual table. */ +struct _Jv_VTable +{ + jclass clas; + void *method[1]; +}; + +/* Extract a character from a Java-style Utf8 string. + * PTR points to the current character. + * LIMIT points to the end of the Utf8 string. + * PTR is incremented to point after the character thta gets returns. + * On an error, -1 is returned. */ +#define UTF8_GET(PTR, LIMIT) \ + ((PTR) >= (LIMIT) ? -1 \ + : *(PTR) < 128 ? *(PTR)++ \ + : (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \ + ? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \ + : (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \ + && ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \ + ? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \ + : ((PTR)++, -1)) + +extern int _Jv_strLengthUtf8(char* str, int len); + +typedef struct _Jv_Utf8Const Utf8Const; +_Jv_Utf8Const *_Jv_makeUtf8Const (char *s, int len); +extern jboolean _Jv_equalUtf8Consts (_Jv_Utf8Const *, _Jv_Utf8Const *); +extern jboolean _Jv_equal (_Jv_Utf8Const *, jstring, jint); + +#define StringClass _CL_Q34java4lang6String +extern java::lang::Class StringClass; + +/* Type of pointer used as finalizer. */ +typedef void _Jv_FinalizerFunc (jobject); + +/* Allocate space for a new Java object. */ +void *_Jv_AllocObj (jsize size); +/* Allocate space for an array of Java objects. */ +void *_Jv_AllocArray (jsize size); +/* Allocate space that is known to be pointer-free. */ +void *_Jv_AllocBytes (jsize size); +/* Initialize the GC. */ +void _Jv_InitGC (void); +/* Register a finalizer. */ +void _Jv_RegisterFinalizer (void *object, _Jv_FinalizerFunc *method); + +/* Run finalizers for objects ready to be finalized.. */ +void _Jv_RunFinalizers (void); +/* Run all finalizers. Should be called only before exit. */ +void _Jv_RunAllFinalizers (void); +/* Perform a GC. */ +void _Jv_RunGC (void); + +/* Return approximation of total size of heap. */ +long _Jv_GCTotalMemory (void); +/* Return approximation of total free memory. */ +long _Jv_GCFreeMemory (void); + +/* Allocate some unscanned bytes. Throw exception if out of memory. */ +void *_Jv_AllocBytesChecked (jsize size); + +// This function is used to determine the hash code of an object. +inline jint +_Jv_HashCode (jobject obj) +{ + return (jint) obj; +} + +extern "C" void _Jv_ThrowBadArrayIndex (jint bad_index); +extern "C" jobject _Jv_NewArray (jint type, jint size); +extern "C" jobject _Jv_NewMultiArray (jclass klass, jint dims, ...); +extern "C" void *_Jv_CheckCast (jclass klass, jobject obj); +extern "C" void *_Jv_LookupInterfaceMethod (jclass klass, Utf8Const *name, + Utf8Const *signature); +extern "C" void _Jv_CheckArrayStore (jobject array, jobject obj); +extern "C" void _Jv_RegisterClass (jclass klass); +extern "C" void _Jv_RegisterClasses (jclass *classes); +extern jclass _Jv_FindClass (_Jv_Utf8Const *name, + java::lang::ClassLoader *loader); +extern jclass _Jv_FindClassFromSignature (char *, + java::lang::ClassLoader *loader); + +extern jobject _Jv_NewMultiArray (jclass, jint ndims, jint* dims); + +#endif /* __JAVA_JVM_H__ */ diff --git a/libjava/include/no-gc.h b/libjava/include/no-gc.h new file mode 100644 index 00000000000..f5775b9f5e5 --- /dev/null +++ b/libjava/include/no-gc.h @@ -0,0 +1,17 @@ +// -*- c++ -*- +// no-gc.h - Defines for no garbage collector. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JV_NO_GC__ +#define __JV_NO_GC__ + +// Nothing. + +#endif /* __JV_NO_GC__ */ diff --git a/libjava/include/no-threads.h b/libjava/include/no-threads.h new file mode 100644 index 00000000000..5de33868eaa --- /dev/null +++ b/libjava/include/no-threads.h @@ -0,0 +1,154 @@ +// -*- c++ -*- +// no-threads.h - Defines for using no threads. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JV_NO_THREADS__ +#define __JV_NO_THREADS__ + +#include "config.h" + +#include +#ifdef HAVE_UNISTD_H +#include +#endif + +// +// Typedefs. +// + +typedef int _Jv_ConditionVariable_t; +typedef int _Jv_Mutex_t; +typedef int _Jv_Thread_t; +typedef void _Jv_ThreadStartFunc (java::lang::Thread *); + + +// +// Condition variables. +// + +inline void +_Jv_CondInit (_Jv_ConditionVariable_t *) +{ +} + +// Waiting is ok provided there is a timeout. Otherwise we will just +// wait forever. +inline int +_Jv_CondWait (_Jv_ConditionVariable_t *, _Jv_Mutex_t *, + jlong millis, jint nanos) +{ + if (millis == 0 && nanos == 0) + JvFail ("_Jv_CondWait without timeout"); + +#ifdef HAVE_SLEEP + int seconds = millis / 1000; + if (seconds > 0) + sleep (seconds); +#endif + + return 0; +} + +inline int +_Jv_CondNotify (_Jv_ConditionVariable_t *, _Jv_Mutex_t *) +{ + // It is ok to notify -- it just has no effect. + return 0; +} + +inline int +_Jv_CondNotifyAll (_Jv_ConditionVariable_t *, _Jv_Mutex_t *) +{ + // It is ok to notify -- it just has no effect. + return 0; +} + + +// +// Mutexes. +// + +inline void +_Jv_MutexInit (_Jv_Mutex_t *) +{ +} + +inline int +_Jv_MutexLock (_Jv_Mutex_t *) +{ + return 0; +} + +inline int +_Jv_MutexUnlock (_Jv_Mutex_t *) +{ + return 0; +} + + +// +// Thread creation and manipulation. +// + +inline void +_Jv_InitThreads (void) +{ +} + +inline void +_Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *) +{ + *data = NULL; +} + +inline java::lang::Thread * +_Jv_ThreadCurrent (void) +{ + extern java::lang::Thread *_Jv_OnlyThread; + return _Jv_OnlyThread; +} + +inline void +_Jv_ThreadYield (void) +{ +} + +inline void +_Jv_ThreadSetPriority (_Jv_Thread_t *, jint) +{ +} + +inline void +_Jv_ThreadCancel (_Jv_Thread_t *, void *) +{ + JvFail ("_Jv_ThreadCancel"); +} + +// Like Cancel, but doesn't run cleanups. +inline void +_Jv_ThreadDestroy (_Jv_Thread_t *) +{ + JvFail ("_Jv_ThreadDestroy"); +} + +void _Jv_ThreadStart (java::lang::Thread *, _Jv_Thread_t *, + _Jv_ThreadStartFunc *meth); + +inline void +_Jv_ThreadWait (void) +{ +} + +inline void +_Jv_ThreadInterrupt (_Jv_Thread_t *) +{ +} + +#endif /* __JV_NO_THREADS__ */ diff --git a/libjava/include/posix-threads.h b/libjava/include/posix-threads.h new file mode 100644 index 00000000000..6e4cc70c020 --- /dev/null +++ b/libjava/include/posix-threads.h @@ -0,0 +1,210 @@ +// -*- c++ -*- +// posix-threads.h - Defines for using POSIX threads. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JV_POSIX_THREADS__ +#define __JV_POSIX_THREADS__ + +// NOTE: This file may only reference those pthread functions which +// are known not to be overridden by the Boehm GC. If in doubt, scan +// boehm-gc/gc.h. This is yucky but lets us avoid including gc.h +// everywhere (which would be truly yucky). + +#include +#include + +#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) || defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP) +# define HAVE_RECURSIVE_MUTEX 1 +#endif + + +// +// Typedefs. +// + +typedef pthread_cond_t _Jv_ConditionVariable_t; +#ifdef HAVE_RECURSIVE_MUTEX +typedef pthread_mutex_t _Jv_Mutex_t; +#else +// Some systems do not have recursive mutexes, so we must simulate +// them. Solaris is one such system. +typedef struct +{ + // Mutex used when locking this structure transiently. + pthread_mutex_t mutex; + // Mutex the thread holds the entire time this mutex is held. This + // is used to make condition variables work properly. + pthread_mutex_t mutex2; + // Condition variable used when waiting for this lock. + pthread_cond_t cond; + // Thread holding this mutex. If COUNT is 0, no thread is holding. + pthread_t thread; + // Number of times mutex is held. If 0, the lock is not held. + int count; +} _Jv_Mutex_t; +#endif /* HAVE_RECURSIVE_MUTEX */ + +typedef struct +{ + // Flag values are defined in implementation. + int flags; + + // Actual thread id. + pthread_t thread; + + // Exception we want to throw when cancelled. + void *exception; +} _Jv_Thread_t; +typedef void _Jv_ThreadStartFunc (java::lang::Thread *); + + +// +// Condition variables. +// + +inline void +_Jv_CondInit (_Jv_ConditionVariable_t *cv) +{ + pthread_cond_init (cv, 0); +} + +#ifndef LINUX_THREADS + +// pthread_cond_destroy does nothing on Linux and it is a win to avoid +// defining this macro. + +#define _Jv_HaveCondDestroy + +inline void +_Jv_CondDestroy (_Jv_ConditionVariable_t *cv) +{ + pthread_cond_destroy (cv); +} + +#endif /* LINUX_THREADS */ + +int _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, + jlong millis, jint nanos); + +inline int +_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *) +{ + // FIXME: check to see if mutex is held by current thread. + return pthread_cond_signal (cv); +} + +inline int +_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *) +{ + // FIXME: check to see if mutex is held by current thread. + return pthread_cond_broadcast (cv); +} + + +// +// Mutexes. +// + +#ifdef RECURSIVE_MUTEX_IS_DEFAULT +inline void +_Jv_MutexInit (_Jv_Mutex_t *mu) +{ + pthread_mutex_init (mu, NULL); +} +#else +void _Jv_MutexInit (_Jv_Mutex_t *mu); +#endif + +#ifndef LINUX_THREADS + +// pthread_mutex_destroy does nothing on Linux and it is a win to avoid +// defining this macro. + +#define _Jv_HaveMutexDestroy + +#ifdef HAVE_RECURSIVE_MUTEX + +inline void +_Jv_MutexDestroy (_Jv_Mutex_t *mu) +{ + pthread_mutex_destroy (mu); +} + +#else /* HAVE_RECURSIVE_MUTEX */ + +extern void _Jv_MutexDestroy (_Jv_Mutex_t *mu); + +#endif /* HAVE_RECURSIVE_MUTEX */ +#endif /* LINUX_THREADS */ + +#ifdef HAVE_RECURSIVE_MUTEX + +inline int +_Jv_MutexLock (_Jv_Mutex_t *mu) +{ + return pthread_mutex_lock (mu); +} + +inline int +_Jv_MutexUnlock (_Jv_Mutex_t *mu) +{ + return pthread_mutex_unlock (mu); +} + +#else /* HAVE_RECURSIVE_MUTEX */ + +extern int _Jv_MutexLock (_Jv_Mutex_t *mu); +extern int _Jv_MutexUnlock (_Jv_Mutex_t *mu); + +#endif /* HAVE_RECURSIVE_MUTEX */ + + +// +// Thread creation and manipulation. +// + +void _Jv_InitThreads (void); + +void _Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *thread); + +inline java::lang::Thread * +_Jv_ThreadCurrent (void) +{ + extern pthread_key_t _Jv_ThreadKey; + return (java::lang::Thread *) pthread_getspecific (_Jv_ThreadKey); +} + +inline void +_Jv_ThreadYield (void) +{ +#ifdef HAVE_SCHED_YIELD + sched_yield (); +#endif /* HAVE_SCHED_YIELD */ +} + +void _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio); + +void _Jv_ThreadCancel (_Jv_Thread_t *data, void *error); + +// Like Cancel, but doesn't run cleanups. +inline void +_Jv_ThreadDestroy (_Jv_Thread_t *) +{ + JvFail ("_Jv_ThreadDestroy"); +} + +void _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data, + _Jv_ThreadStartFunc *meth); + +void _Jv_ThreadWait (void); + +void _Jv_ThreadInterrupt (_Jv_Thread_t *data); + +#endif /* __JV_POSIX_THREADS__ */ diff --git a/libjava/include/quick-threads.h b/libjava/include/quick-threads.h new file mode 100644 index 00000000000..3ce8ece2168 --- /dev/null +++ b/libjava/include/quick-threads.h @@ -0,0 +1,139 @@ +// -*- c++ -*- +// quick-threads.h - Defines for using QuickThreads. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JV_QUICK_THREADS__ +#define __JV_QUICK_THREADS__ + +#include + +// +// Typedefs. +// + +typedef coop_c _Jv_ConditionVariable_t; +typedef coop_m _Jv_Mutex_t; +typedef coop_t *_Jv_Thread_t; +typedef void _Jv_ThreadStartFunc (java::lang::Thread *); + + +// +// Condition variables. +// + +inline void +_Jv_CondInit (_Jv_ConditionVariable_t *cv) +{ + coop_condition_variable_init (cv); +} + +inline int +_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, + jlong millis, jint nanos) +{ + return coop_condition_variable_wait (cv, mu, millis * 1000 + nanos / 1000); +} + +inline int +_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu) +{ + return coop_condition_variable_signal (cv, mu); +} + +inline int +_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu) +{ + return coop_condition_variable_signal_all (cv, mu); +} + + +// +// Mutexes. +// + +inline void +_Jv_MutexInit (_Jv_Mutex_t *mu) +{ + coop_mutex_init (mu); +} + +inline int +_Jv_MutexLock (_Jv_Mutex_t *mu) +{ + coop_mutex_lock (mu); + return 0; +} + +inline int +_Jv_MutexUnlock (_Jv_Mutex_t *mu) +{ + return coop_mutex_unlock (mu); +} + + +// +// Thread creation and manipulation. +// + +void _Jv_InitThreads (void); + +inline void +_Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *) +{ + *data = new _Jv_Thread_t; + **data = (coop_t *) 0; +} + +inline java::lang::Thread * +_Jv_ThreadCurrent (void) +{ + extern int _Jv_ThreadKey; + return (java::lang::Thread *) coop_getspecific (_Jv_ThreadKey); +} + +inline void +_Jv_ThreadYield (void) +{ + coop_yield (); +} + +inline void +_Jv_ThreadSetPriority (_Jv_Thread_t *, jint) +{ +} + +inline void +_Jv_ThreadCancel (_Jv_Thread_t *data, void *error) +{ + coop_terminate (*data, error); +} + +// Like Cancel, but doesn't run cleanups. +inline void +_Jv_ThreadDestroy (_Jv_Thread_t *data) +{ + coop_terminate (*data, 0); +} + +void _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data, + _Jv_ThreadStartFunc *meth); + +inline void +_Jv_ThreadWait (void) +{ + coop_start (); +} + +inline void +_Jv_ThreadInterrupt (_Jv_Thread_t *) +{ +} + +#endif /* __JV_QUICK_THREADS__ */ diff --git a/libjava/java/io/BufferedInputStream.java b/libjava/java/io/BufferedInputStream.java new file mode 100644 index 00000000000..698abf608af --- /dev/null +++ b/libjava/java/io/BufferedInputStream.java @@ -0,0 +1,168 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 8, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class BufferedInputStream extends FilterInputStream +{ + /* Internal buffer array for data. */ + protected byte[] buf; + + /* Index one greater than the last valid byte in the buffer. */ + protected int count = 0; + + /* The current position in the buffer. */ + protected int pos = 0; + + /* The value of pos the last time mark() was called. */ + protected int markpos = -1; + + /* The maximum read-ahead allowed before calls to reset() fail. */ + protected int marklimit = 0; + + public BufferedInputStream(InputStream in) + { + this(in, 2048); + } + + public BufferedInputStream(InputStream in, int size) + { + super(in); + if (size <= 0) + throw new IllegalArgumentException(); + buf = new byte[size]; + } + + public synchronized int available() throws IOException + { + return count - pos + super.available(); + } + + public void close() throws IOException + { + // Free up the array memory. + buf = null; + super.close(); + } + + public synchronized void mark(int readlimit) + { + marklimit = readlimit; + markpos = pos; + } + + public boolean markSupported() + { + return true; + } + + public synchronized int read() throws IOException + { + if (pos >= count && !refill()) + return -1; // EOF + + if (markpos >= 0 && pos - markpos > marklimit) + markpos = -1; + + return ((int) buf[pos++]) & 0xFF; + } + + public synchronized int read(byte[] b, int off, int len) throws IOException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + if (pos >= count && !refill()) + return -1; // No bytes were read before EOF. + + int remain = Math.min(count - pos, len); + System.arraycopy(buf, pos, b, off, remain); + pos += remain; + + if (markpos >= 0 && pos - markpos > marklimit) + markpos = -1; + + return remain; + } + + public synchronized void reset() throws IOException + { + if (markpos < 0) + throw new IOException(); + + pos = markpos; + } + + public synchronized long skip(long n) throws IOException + { + final long origN = n; + + while (n > 0L) + { + if (pos >= count && !refill()) + if (n < origN) + break; + else + return -1; // No bytes were read before EOF. + + int numread = (int) Math.min((long) (count - pos), n); + pos += numread; + n -= numread; + + if (markpos >= 0 && pos - markpos > marklimit) + markpos = -1; + } + + return origN - n; + } + + private boolean refill() throws IOException + { + if (markpos < 0) + count = pos = 0; + else if (markpos > 0) + { + // Shift the marked bytes (if any) to the beginning of the array + // but don't grow it. This saves space in case a reset is done + // before we reach the max capacity of this array. + System.arraycopy(buf, markpos, buf, 0, count - markpos); + count -= markpos; + pos -= markpos; + markpos = 0; + } + else if (marklimit >= buf.length) // BTW, markpos == 0 + { + // Need to grow the buffer now to have room for marklimit bytes. + // Note that the new buffer is one greater than marklimit. + // This is so that there will be one byte past marklimit to be read + // before having to call refill again, thus allowing marklimit to be + // invalidated. That way refill doesn't have to check marklimit. + byte[] newbuf = new byte[marklimit + 1]; + System.arraycopy(buf, 0, newbuf, 0, count); + buf = newbuf; + } + + int numread = super.read(buf, count, buf.length - count); + + if (numread < 0) // EOF + return false; + + count += numread; + return true; + } +} diff --git a/libjava/java/io/BufferedOutputStream.java b/libjava/java/io/BufferedOutputStream.java new file mode 100644 index 00000000000..d37ed5d2cb0 --- /dev/null +++ b/libjava/java/io/BufferedOutputStream.java @@ -0,0 +1,76 @@ +// BufferedOutputStream.java - A buffered stream + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public class BufferedOutputStream extends FilterOutputStream +{ + public BufferedOutputStream (OutputStream ox) + { + this (ox, 512); + } + + public BufferedOutputStream (OutputStream ox, int size) + { + super (ox); + buf = new byte[size]; + } + + public synchronized void flush () throws IOException + { + out.write(buf, 0, count); + count = 0; + out.flush(); + } + + public synchronized void write (int b) throws IOException + { + if (count < buf.length) + buf[count++] = (byte) b; + else + { + out.write(buf, 0, count); + count = 0; + out.write(b); + } + } + + public synchronized void write (byte[] b, int off, int len) + throws IOException, NullPointerException, IndexOutOfBoundsException + { + // If LEN < 0 then the downstream write will fail for us. + if (len >= 0 && count + len < buf.length) + { + System.arraycopy(b, off, buf, count, len); + count += len; + } + else + { + out.write(buf, 0, count); + count = 0; + out.write(b, off, len); + } + } + + // The buffer. + protected byte[] buf; + // Number of valid bytes in BUF. + protected int count; +} diff --git a/libjava/java/io/BufferedReader.java b/libjava/java/io/BufferedReader.java new file mode 100644 index 00000000000..19e371a24e3 --- /dev/null +++ b/libjava/java/io/BufferedReader.java @@ -0,0 +1,373 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Per Bothner + * @date April 22, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class BufferedReader extends Reader +{ + Reader in; + char[] buffer; + /* Index of current read position. Must be >= 0 and <= limit. */ + /* There is a special case where pos may be equal to limit+1; this + * is used as an indicator that a readLine was done with a '\r' was + * the very last char in the buffer. Since we don't want to read-ahead + * and potentially block, we set pos this way to indicate the situation + * and deal with it later. Doing it this way rather than having a + * separate boolean field to indicate the condition has the advantage + * that it is self-clearing on things like mark/reset. + */ + int pos; + /* Limit of valid data in buffer. Must be >= pos and <= buffer.length. */ + /* This can be < pos in the one special case described above. */ + int limit; + + /* The value -1 means there is no mark, or the mark has been invalidated. + Otherwise, markPos is the index in the buffer of the marked position. + Must be >= 0 and <= pos. + Note we do not explicitly store the read-limit. + The implicit read-limit is (buffer.length - markPos), which is + guaranteed to be >= the read-limit requested in the call to mark. */ + int markPos = -1; + + public BufferedReader(Reader in) + { + this(in, 8192); + } + + public BufferedReader(Reader in, int size) + { + super(in.lock); + this.in = in; + buffer = new char[size]; + } + + public void close() throws IOException + { + synchronized (lock) + { + if (in != null) + in.close(); + in = null; + buffer = null; + } + } + + public boolean markSupported() + { + return true; + } + + public void mark(int readLimit) throws IOException + { + synchronized (lock) + { + // In this method we need to be aware of the special case where + // pos + 1 == limit. This indicates that a '\r' was the last char + // in the buffer during a readLine. We'll want to maintain that + // condition after we shift things around and if a larger buffer is + // needed to track readLimit, we'll have to make it one element + // larger to ensure we don't invalidate the mark too early, if the + // char following the '\r' is NOT a '\n'. This is ok because, per + // the spec, we are not required to invalidate when passing readLimit. + // + // Note that if 'pos > limit', then doing 'limit -= pos' will cause + // limit to be negative. This is the only way limit will be < 0. + + if (pos + readLimit > limit) + { + char[] old_buffer = buffer; + int extraBuffSpace = 0; + if (pos > limit) + extraBuffSpace = 1; + if (readLimit + extraBuffSpace > limit) + buffer = new char[readLimit + extraBuffSpace]; + limit -= pos; + if (limit >= 0) + { + System.arraycopy(old_buffer, pos, buffer, 0, limit); + pos = 0; + } + } + + if (limit < 0) + { + // Maintain the relationship of 'pos > limit'. + pos = 1; + limit = markPos = 0; + } + else + markPos = pos; + // Now pos + readLimit <= buffer.length. thus if we need to read + // beyond buffer.length, then we are allowed to invalidate markPos. + } + } + + public void reset() throws IOException + { + synchronized (lock) + { + if (markPos < 0) + throw new IOException("mark never set or invalidated"); + + // Need to handle the extremely unlikely case where a readLine was + // done with a '\r' as the last char in the buffer; which was then + // immediately followed by a mark and a reset with NO intervening + // read of any sort. In that case, setting pos to markPos would + // lose that info and a subsequent read would thus not skip a '\n' + // (if one exists). The value of limit in this rare case is zero. + // We can assume that if limit is zero for other reasons, then + // pos is already set to zero and doesn't need to be readjusted. + if (limit > 0) + pos = markPos; + } + } + + public boolean ready() throws IOException + { + synchronized (lock) + { + return pos < limit || in.ready(); + } + } + + public int read(char[] buf, int offset, int count) throws IOException + { + synchronized (lock) + { + // Once again, we need to handle the special case of a readLine + // that has a '\r' at the end of the buffer. In this case, we'll + // need to skip a '\n' if it is the next char to be read. + // This special case is indicated by 'pos > limit'. + boolean retAtEndOfBuffer = false; + + int avail = limit - pos; + if (count > avail) + { + if (avail > 0) + count = avail; + else // pos >= limit + { + if (limit == buffer.length) + markPos = -1; // read too far - invalidate the mark. + if (pos > limit) + { + // Set a boolean and make pos == limit to simplify things. + retAtEndOfBuffer = true; + --pos; + } + if (markPos < 0) + { + // Optimization: can read directly into buf. + if (count >= buffer.length && !retAtEndOfBuffer) + return in.read(buf, offset, count); + pos = limit = 0; + } + avail = in.read(buffer, limit, buffer.length - limit); + if (retAtEndOfBuffer && avail > 0 && buffer[limit] == '\n') + { + --avail; + limit++; + } + if (avail < count) + { + if (avail <= 0) + return avail; + count = avail; + } + limit += avail; + } + } + System.arraycopy(buffer, pos, buf, offset, count); + pos += count; + return count; + } + } + + /* Read more data into the buffer. Update pos and limit appropriatly. + Assumes pos==limit initially. May invalidate the mark if read too much. + Return number of chars read (never 0), or -1 on eof. */ + private int fill() throws IOException + { + // Handle the special case of a readLine that has a '\r' at the end of + // the buffer. In this case, we'll need to skip a '\n' if it is the + // next char to be read. This special case is indicated by 'pos > limit'. + boolean retAtEndOfBuffer = false; + if (pos > limit) + { + retAtEndOfBuffer = true; + --pos; + } + + if (markPos >= 0 && limit == buffer.length) + markPos = -1; + if (markPos <= 0) + pos = limit = 0; + int count = in.read(buffer, limit, buffer.length - limit); + if (count > 0) + limit += count; + + if (retAtEndOfBuffer && buffer[pos] == '\n') + { + --count; + pos++; + } + + return count; + } + + public int read() throws IOException + { + synchronized (lock) + { + if (pos >= limit && fill () <= 0) + return -1; + return buffer[pos++]; + } + } + + /* Return the end of the line starting at this.pos and ending at limit. + * The index returns is *before* any line terminators, or limit + * if no line terminators were found. + */ + private int lineEnd(int limit) + { + int i = pos; + for (; i < limit; i++) + { + char ch = buffer[i]; + if (ch == '\n' || ch == '\r') + break; + } + return i; + } + + public String readLine() throws IOException + { + // Handle the special case where a previous readLine (with no intervening + // reads/skips) had a '\r' at the end of the buffer. + // In this case, we'll need to skip a '\n' if it's the next char to be read. + // This special case is indicated by 'pos > limit'. + if (pos > limit) + { + int ch = read(); + if (ch < 0) + return null; + if (ch != '\n') + --pos; + } + int i = lineEnd(limit); + if (i < limit) + { + String str = new String(buffer, pos, i - pos); + pos = i + 1; + // If the last char in the buffer is a '\r', we must remember + // to check if the next char to be read after the buffer is refilled + // is a '\n'. If so, skip it. To indicate this condition, we set pos + // to be limit + 1, which normally is never possible. + if (buffer[i] == '\r') + if (pos == limit || buffer[pos] == '\n') + pos++; + return str; + } + StringBuffer sbuf = new StringBuffer(200); + sbuf.append(buffer, pos, i - pos); + pos = i; + // We only want to return null when no characters were read before + // EOF. So we must keep track of this separately. Otherwise we + // would treat an empty `sbuf' as an EOF condition, which is wrong + // when there is just a newline. + boolean eof = false; + for (;;) + { + int ch = read(); + if (ch < 0) + { + eof = true; + break; + } + if (ch == '\n' || ch == '\r') + { + // Check here if a '\r' was the last char in the buffer; if so, + // mark it as in the comment above to indicate future reads + // should skip a newline that is the next char read after + // refilling the buffer. + if (ch == '\r') + if (pos == limit || buffer[pos] == '\n') + pos++; + break; + } + i = lineEnd(limit); + sbuf.append(buffer, pos - 1, i - (pos - 1)); + pos = i; + } + return (sbuf.length() == 0 && eof) ? null : sbuf.toString(); + } + + public long skip(long count) throws IOException + { + if (count <= 0) + return 0; + synchronized (lock) + { + // Yet again, we need to handle the special case of a readLine + // that has a '\r' at the end of the buffer. In this case, we need + // to ignore a '\n' if it is the next char to be read. + // This special case is indicated by 'pos > limit' (i.e. avail < 0). + // To simplify things, if we're dealing with the special case for + // readLine, just read the next char (since the fill method will + // skip the '\n' for us). By doing this, we'll have to back up pos. + // That's easier than trying to keep track of whether we've skipped + // one element or not. + int ch; + if (pos > limit) + if ((ch = read()) < 0) + return 0; + else + --pos; + + int avail = limit - pos; + + if (count < avail) + { + pos += count; + return count; + } + + pos = limit; + long todo = count - avail; + if (todo > buffer.length) + { + markPos = -1; + todo -= in.skip(todo); + } + else + { + while (todo > 0) + { + avail = fill(); + if (avail <= 0) + break; + if (avail > todo) + avail = (int) todo; + pos += avail; + todo -= avail; + } + } + return count - todo; + } + } +} diff --git a/libjava/java/io/BufferedWriter.java b/libjava/java/io/BufferedWriter.java new file mode 100644 index 00000000000..85aceed68bd --- /dev/null +++ b/libjava/java/io/BufferedWriter.java @@ -0,0 +1,129 @@ +// BufferedWriter.java - Filtered character output stream. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +// Why not extend FilterWriter? +public class BufferedWriter extends Writer +{ + public BufferedWriter (Writer out) + { + this (out, 8192); + } + + public BufferedWriter (Writer ox, int size) + { + super (ox); + out = ox; + buffer = new char[size]; + count = 0; + } + + public void close () throws IOException + { + localFlush (); + out.close(); + } + + public void flush () throws IOException + { + localFlush (); + out.flush(); + } + + public void newLine () throws IOException + { + write (System.getProperty("line.separator")); + } + + public void write (int oneChar) throws IOException + { + synchronized (lock) + { + buffer[count++] = (char) oneChar; + if (count == buffer.length) + localFlush (); + } + } + + public void write (char[] buf, int offset, int len) throws IOException + { + if (offset < 0 || len < 0 || offset + len > buf.length) + throw new ArrayIndexOutOfBoundsException (); + + synchronized (lock) + { + // Bypass buffering if there is too much incoming data. + if (count + len > buffer.length) + { + localFlush (); + out.write(buf, offset, len); + } + else + { + System.arraycopy(buf, offset, buffer, count, len); + count += len; + if (count == buffer.length) + localFlush (); + } + } + } + + public void write (String str, int offset, int len) throws IOException + { + if (offset < 0 || len < 0 || offset + len < str.length()) + throw new ArrayIndexOutOfBoundsException (); + + synchronized (lock) + { + if (count + len > buffer.length) + { + localFlush (); + out.write(str, offset, len); + } + else + { + str.getChars(offset, offset + len, buffer, count); + count += len; + if (count == buffer.length) + localFlush (); + } + } + } + + private final void localFlush () throws IOException + { + if (count > 0) + { + synchronized (lock) + { + out.write(buffer, 0, count); + count = 0; + } + } + } + + // The downstream writer. + private Writer out; + // The character buffer. + char[] buffer; + // Number of valid chars in buffer. + int count; +} diff --git a/libjava/java/io/ByteArrayInputStream.java b/libjava/java/io/ByteArrayInputStream.java new file mode 100644 index 00000000000..9b9bf964baa --- /dev/null +++ b/libjava/java/io/ByteArrayInputStream.java @@ -0,0 +1,113 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 7, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +public class ByteArrayInputStream extends InputStream +{ + /* An array of bytes provided by the creator of the stream. */ + protected byte[] buf; + + /* Position of the next byte in buf to be read. */ + protected int pos; + + /* The currently marked position in the stream. */ + protected int mark; + + /* The index in buf one greater than the last valid character. */ + protected int count; + + public ByteArrayInputStream(byte[] buffer) + { + this(buffer, 0, buffer.length); + } + + public ByteArrayInputStream(byte[] buffer, int offset, int length) + { + buf = buffer; + + count = offset + length; + if (count > buf.length) + count = buf.length; + + pos = offset; + // TBD: What should we do if pos is neg. or > count? E.g. throw exc. or: + // if (pos < 0 || pos > count) + // pos = 0; + + mark = pos; + } + + public synchronized int available() + { + return count - pos; + } + + public synchronized void mark(int readAheadLimit) + { + // readAheadLimit is ignored per Java Class Lib. book, p.220. + mark = pos; + } + + public boolean markSupported() + { + return true; + } + + public synchronized int read() + { + if (pos < 0) + throw new ArrayIndexOutOfBoundsException(pos); + + if (pos < count) + return ((int) buf[pos++]) & 0xFF; + return -1; + } + + public synchronized int read(byte[] b, int off, int len) + { + /* Don't need to check pos value, arraycopy will check it. */ + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + if (pos >= count) + return -1; + + int numBytes = Math.min(count - pos, len); + System.arraycopy(buf, pos, b, off, numBytes); + pos += numBytes; + return numBytes; + } + + public synchronized void reset() + { + pos = mark; + } + + public synchronized long skip(long n) + { + // Even though the var numBytes is a long, in reality it can never + // be larger than an int since the result of subtracting 2 positive + // ints will always fit in an int. Since we have to return a long + // anyway, numBytes might as well just be a long. + long numBytes = Math.min((long) (count - pos), n < 0 ? 0L : n); + pos += numBytes; + return numBytes; + } +} diff --git a/libjava/java/io/ByteArrayOutputStream.java b/libjava/java/io/ByteArrayOutputStream.java new file mode 100644 index 00000000000..4d5f224e376 --- /dev/null +++ b/libjava/java/io/ByteArrayOutputStream.java @@ -0,0 +1,108 @@ +// ByteArrayOutputStream.java - Write bytes to an array. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public class ByteArrayOutputStream extends OutputStream +{ + public ByteArrayOutputStream () + { + this (32); + } + + public ByteArrayOutputStream (int size) + { + buf = new byte[size]; + count = 0; + } + + public synchronized void reset () + { + count = 0; + } + + public int size () + { + return count; + } + + public synchronized byte[] toByteArray () + { + byte[] ret = new byte[count]; + System.arraycopy(buf, 0, ret, 0, count); + return ret; + } + + public String toString () + { + return new String (buf, 0, count); + } + + public String toString (String enc) throws UnsupportedEncodingException + { + return new String (buf, 0, count, enc); + } + + // This is deprecated in the JCL book. + public String toString (int hibyte) + { + return new String (buf, 0, count, hibyte); + } + + // Resize buffer to accomodate new bytes. + private void resize (int add) + { + if (count + add >= buf.length) + { + int newlen = buf.length * 2; + if (count + add > newlen) + newlen = count + add; + byte[] newbuf = new byte[newlen]; + System.arraycopy(buf, 0, newbuf, 0, count); + buf = newbuf; + } + } + + public synchronized void write (int oneByte) + { + resize (1); + buf[count++] = (byte) oneByte; + } + + public synchronized void write (byte[] buffer, int offset, int add) + { + // If ADD < 0 then arraycopy will throw the appropriate error for + // us. + if (add >= 0) + resize (add); + System.arraycopy(buffer, offset, buf, count, add); + count += add; + } + + public synchronized void writeTo (OutputStream out) throws IOException + { + out.write(buf, 0, count); + } + + // The byte buffer. + protected byte[] buf; + // Number of valid bytes in buffer. + protected int count; +} diff --git a/libjava/java/io/CharArrayReader.java b/libjava/java/io/CharArrayReader.java new file mode 100644 index 00000000000..a43e8da62e9 --- /dev/null +++ b/libjava/java/io/CharArrayReader.java @@ -0,0 +1,152 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 16, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +public class CharArrayReader extends Reader +{ + /* An array of chars provided by the creator of the stream. */ + protected char[] buf; + + /* Position of the next char in buf to be read. */ + protected int pos; + + /* The currently marked position in the stream. */ + protected int markedPos; + + /* The index in buf one greater than the last valid character. */ + protected int count; + + public CharArrayReader(char[] buffer) + { + this(buffer, 0, buffer.length); + } + + public CharArrayReader(char[] buffer, int offset, int length) + { + super(); + buf = buffer; + + count = offset + length; + if (count > buf.length) + count = buf.length; + + pos = offset; + // TBD: What should we do if pos is neg. or > count? E.g. throw exc. or: + // if (pos < 0 || pos > count) + // pos = 0; + + markedPos = pos; + } + + public void close() + { + synchronized (lock) + { + buf = null; + } + } + + public void mark(int readAheadLimit) + { + synchronized (lock) + { + // readAheadLimit is ignored per Java Class Lib. book, p. 318. + markedPos = pos; + } + } + + public boolean markSupported() + { + return true; + } + + public int read() throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + if (pos < 0) + throw new ArrayIndexOutOfBoundsException(pos); + + if (pos < count) + return ((int) buf[pos++]) & 0xFFFF; + return -1; + } + } + + public int read(char[] b, int off, int len) throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + /* Don't need to check pos value, arraycopy will check it. */ + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + if (pos >= count) + return -1; + + int numChars = Math.min(count - pos, len); + System.arraycopy(buf, pos, b, off, numChars); + pos += numChars; + return numChars; + } + } + + public boolean ready() throws IOException + { + if (buf == null) + throw new IOException(); + + return true; + } + + public void reset() throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + pos = markedPos; + } + } + + public long skip(long n) throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + // Even though the var numChars is a long, in reality it can never + // be larger than an int since the result of subtracting 2 positive + // ints will always fit in an int. Since we have to return a long + // anyway, numChars might as well just be a long. + long numChars = Math.min((long) (count - pos), n < 0 ? 0L : n); + pos += numChars; + return numChars; + } + } +} diff --git a/libjava/java/io/CharArrayWriter.java b/libjava/java/io/CharArrayWriter.java new file mode 100644 index 00000000000..3e1e4a4f78e --- /dev/null +++ b/libjava/java/io/CharArrayWriter.java @@ -0,0 +1,122 @@ +// CharArrayWriter.java - Character array output stream. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class CharArrayWriter extends Writer +{ + public CharArrayWriter () + { + this (32); + } + + public CharArrayWriter (int size) + { + super (); + buf = new char[size]; + } + + public void close () + { + // JCL says this does nothing. This seems to violate the Writer + // contract, in that other methods should still throw and + // IOException after a close. Still, we just follow JCL. + } + + public void flush () + { + } + + public synchronized void reset () + { + count = 0; + } + + public int size () + { + return count; + } + + public char[] toCharArray () + { + char[] nc = new char[count]; + System.arraycopy(buf, 0, nc, 0, count); + return nc; + } + + public String toString () + { + return new String (buf, 0, count); + } + + public void write (int oneChar) + { + synchronized (lock) + { + resize (1); + buf[count++] = (char) oneChar; + } + } + + public void write (char[] buffer, int offset, int len) + { + synchronized (lock) + { + if (len >= 0) + resize (len); + System.arraycopy(buffer, offset, buf, count, len); + count += len; + } + } + + public void write (String str, int offset, int len) + { + synchronized (lock) + { + if (len >= 0) + resize (len); + str.getChars(offset, offset + len, buf, count); + count += len; + } + } + + public void writeTo (Writer out) throws IOException + { + out.write(buf, 0, count); + } + + private final void resize (int len) + { + if (count + len >= buf.length) + { + int newlen = buf.length * 2; + if (count + len > newlen) + newlen = count + len; + char[] newbuf = new char[newlen]; + System.arraycopy(buf, 0, newbuf, 0, count); + buf = newbuf; + } + } + + // The character buffer. + protected char[] buf; + // Number of valid characters in buffer. + protected int count; +} diff --git a/libjava/java/io/CharConversionException.java b/libjava/java/io/CharConversionException.java new file mode 100644 index 00000000000..039578e4c52 --- /dev/null +++ b/libjava/java/io/CharConversionException.java @@ -0,0 +1,34 @@ +// CharConversionException.java - Problem converting char to byte encoding. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class CharConversionException extends IOException +{ + public CharConversionException () + { + super (); + } + + public CharConversionException (String s) + { + super (s); + } +} diff --git a/libjava/java/io/DataInput.java b/libjava/java/io/DataInput.java new file mode 100644 index 00000000000..2c6f988cc79 --- /dev/null +++ b/libjava/java/io/DataInput.java @@ -0,0 +1,41 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 2, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public interface DataInput +{ + public boolean readBoolean() throws IOException; + public byte readByte() throws IOException; + public char readChar() throws IOException; + public double readDouble() throws IOException; + public float readFloat() throws IOException; + public void readFully(byte[] b) + throws IOException, NullPointerException; + public void readFully(byte[] b, int off, int len) + throws IOException, NullPointerException, IndexOutOfBoundsException; + public int readInt() throws IOException; + public String readLine() throws IOException; + public long readLong() throws IOException; + public short readShort() throws IOException; + public int readUnsignedByte() throws IOException; + public int readUnsignedShort() throws IOException; + public String readUTF() throws IOException; + public int skipBytes(int n) throws IOException; +} diff --git a/libjava/java/io/DataInputStream.java b/libjava/java/io/DataInputStream.java new file mode 100644 index 00000000000..7c90008c6e0 --- /dev/null +++ b/libjava/java/io/DataInputStream.java @@ -0,0 +1,249 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 20, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class DataInputStream extends FilterInputStream implements DataInput +{ + public DataInputStream(InputStream in) + { + super(in); + } + + public final int read(byte[] b) throws IOException + { + return super.read(b, 0, b.length); + } + + public final int read(byte[] b, int off, int len) throws IOException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + return super.read(b, off, len); + } + + public final boolean readBoolean() throws IOException + { + return (readByte() != 0); + } + + public final byte readByte() throws IOException + { + int i = read(); + if (i < 0) + throw new EOFException(); + + return (byte) i; + } + + public final char readChar() throws IOException + { + return (char) ((readByte() << 8) | readUnsignedByte()); + } + + public final double readDouble() throws IOException + { + return Double.longBitsToDouble(readLong()); + } + + public final float readFloat() throws IOException + { + return Float.intBitsToFloat(readInt()); + } + + public final void readFully(byte[] b) throws IOException + { + readFully(b, 0, b.length); + } + + public final void readFully(byte[] b, int off, int len) throws IOException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + while (len > 0) + { + // super.read will block until some data is available. + int numread = super.read(b, off, len); + if (numread < 0) + throw new EOFException(); + len -= numread; + off += numread; + } + } + + public final int readInt() throws IOException + { + int retval = 0; + for (int i = 0; i < 4; i++) + retval |= readUnsignedByte() << (24 - i * 8); + + return retval; + } + + // Deprecated as of JDK 1.1 + public final String readLine() throws IOException + { + StringBuffer strb = new StringBuffer(); + + while (true) + { + char ch = (char) read(); + if (ch < 0 || (ch &= 0xFF) == '\n') + break; + if (ch == '\r') + { + // FIXME: The following code tries to adjust the stream back one + // character if the next char read is '\n'. As a last resort, + // it tries to mark the position before reading but the bottom + // line is that it is possible that this method will not properly + // deal with a '\r' '\n' combination thus not fulfilling the + // DataInput contract for readLine. It's not a particularly + // safe approach threadwise since it is unsynchronized and + // since it might mark an input stream behind the users back. + // Along the same vein it could try the same thing for + // ByteArrayInputStream and PushbackInputStream, but that is + // probably overkill since this is deprecated & BufferedInputStream + // is the most likely type of input stream. + // + // The alternative is to somehow push back the next byte if it + // isn't a '\n' or to have the reading methods of this class + // keep track of whether the last byte read was '\r' by readLine + // and then skip the very next byte if it is '\n'. Either way, + // this would increase the complexity of the non-deprecated methods + // and since it is undesirable to make non-deprecated methods + // less efficient, the following seems like the most reasonable + // approach. + if (in instanceof BufferedInputStream && (read() & 0xFF) != '\n') + { + BufferedInputStream bin = (BufferedInputStream) in; + if (bin.pos > 0) + bin.pos--; + } + else if (markSupported()) + { + mark(1); + if ((read() & 0xFF) != '\n') + reset(); + } + break; + } + strb.append(ch); + } + + return strb.length() > 0 ? strb.toString() : null; + } + + public final long readLong() throws IOException + { + long retval = 0L; + for (int i = 0; i < 8; i++) + retval |= (long) readUnsignedByte() << (56 - i * 8); + + return retval; + } + + public final short readShort() throws IOException + { + return (short) ((readByte() << 8) | readUnsignedByte()); + } + + public final int readUnsignedByte() throws IOException + { + int i = read(); + if (i < 0) + throw new EOFException(); + + return (i & 0xFF); + } + + public final int readUnsignedShort() throws IOException + { + return (readUnsignedByte() << 8) | readUnsignedByte(); + } + + public final String readUTF() throws IOException + { + return readUTF(this); + } + + public final static String readUTF(DataInput in) throws IOException + { + final int UTFlen = in.readUnsignedShort(); + byte[] buf = new byte[UTFlen]; + StringBuffer strbuf = new StringBuffer(); + + // This blocks until the entire string is available rather than + // doing partial processing on the bytes that are available and then + // blocking. An advantage of the latter is that Exceptions + // could be thrown earlier. The former is a bit cleaner. + in.readFully(buf, 0, UTFlen); + for (int i = 0; i < UTFlen; ) + { + if ((buf[i] & 0x80) == 0) // bit pattern 0xxxxxxx + strbuf.append((char) (buf[i++] & 0xFF)); + else if ((buf[i] & 0xE0) == 0xC0) // bit pattern 110xxxxx + { + if (i + 1 >= UTFlen || (buf[i+1] & 0xC0) != 0x80) + throw new UTFDataFormatException(); + + strbuf.append((char) (((buf[i++] & 0x1F) << 6) | + (buf[i++] & 0x3F))); + } + else if ((buf[i] & 0xF0) == 0xE0) // bit pattern 1110xxxx + { + if (i + 2 >= UTFlen || + (buf[i+1] & 0xC0) != 0x80 || (buf[i+2] & 0xC0) != 0x80) + throw new UTFDataFormatException(); + + strbuf.append((char) (((buf[i++] & 0x0F) << 12) | + ((buf[i++] & 0x3F) << 6) | + (buf[i++] & 0x3F))); + } + else // must be ((buf[i] & 0xF0) == 0xF0 || (buf[i] & 0xC0) == 0x80) + throw new UTFDataFormatException(); // bit patterns 1111xxxx or + // 10xxxxxx + } + + return strbuf.toString(); + } + + public final int skipBytes(int n) throws IOException + { + // The contract in the Java Lang. Spec. says that this never + // throws an EOFException and infers that it doesn't block (since + // it may skip less than the requested number of bytes). + // BUT, the JCL book specifically says that this method blocks + // and can throw an EOFException. Finally, the Java 1.2 online + // doc simply refers to the general contract. As such, we will + // stick to the contract and assume for now that the JCL book + // is incorrect. + + // Since we're only skipping at most an int number of bytes, the cast + // of return value to an int is fine. + if (n > 0) + { + n = Math.min(n, available()); + return (int) super.skip((long) n); + } + + return 0; + } +} diff --git a/libjava/java/io/DataOutput.java b/libjava/java/io/DataOutput.java new file mode 100644 index 00000000000..c3fd366c561 --- /dev/null +++ b/libjava/java/io/DataOutput.java @@ -0,0 +1,44 @@ +// DataOutput.java - Interface for data output conversions. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public interface DataOutput +{ + public abstract void write (int b) throws IOException; + public abstract void write (byte[] b) + throws IOException, NullPointerException; + public abstract void write (byte[] b, int off, int len) + throws IOException, NullPointerException, IndexOutOfBoundsException; + public abstract void writeBoolean (boolean v) throws IOException; + public abstract void writeByte (int v) throws IOException; + public abstract void writeShort (int v) throws IOException; + public abstract void writeChar (int v) throws IOException; + public abstract void writeInt (int v) throws IOException; + public abstract void writeLong (long v) throws IOException; + public abstract void writeFloat (float v) throws IOException; + public abstract void writeDouble (double v) throws IOException; + public abstract void writeBytes (String s) + throws IOException, NullPointerException; + public abstract void writeChars (String s) + throws IOException, NullPointerException; + public abstract void writeUTF (String s) + throws IOException, NullPointerException; +} diff --git a/libjava/java/io/DataOutputStream.java b/libjava/java/io/DataOutputStream.java new file mode 100644 index 00000000000..2ef4cf08885 --- /dev/null +++ b/libjava/java/io/DataOutputStream.java @@ -0,0 +1,165 @@ +// DataOutputStream.java - Output filter that implements DataOutput + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public class DataOutputStream extends FilterOutputStream implements DataOutput +{ + public DataOutputStream (OutputStream out) + { + super (out); + written = 0; + } + + public void flush () throws IOException + { + out.flush(); + } + + public final int size () + { + return written; + } + + public synchronized void write (int b) throws IOException + { + out.write(b); + ++written; + } + + public synchronized void write (byte[] b, int off, int len) + throws IOException, NullPointerException, IndexOutOfBoundsException + { + out.write(b, off, len); + written += len - off; + } + + public final void writeBoolean (boolean v) throws IOException + { + write (v ? 1 : 0); + } + + public final void writeByte (int v) throws IOException + { + write (v & 0xff); + } + + public final void writeShort (int v) throws IOException + { + write ((byte) (0xff & (v >> 8))); + write ((byte) (0xff & v)); + } + + public final void writeChar (int v) throws IOException + { + write ((byte) (0xff & (v >> 8))); + write ((byte) (0xff & v)); + } + + public final void writeInt (int v) throws IOException + { + write ((byte) (0xff & (v >> 24))); + write ((byte) (0xff & (v >> 16))); + write ((byte) (0xff & (v >> 8))); + write ((byte) (0xff & v)); + } + + public final void writeLong (long v) throws IOException + { + write ((byte) (0xff & (v >> 56))); + write ((byte) (0xff & (v >> 48))); + write ((byte) (0xff & (v >> 40))); + write ((byte) (0xff & (v >> 32))); + write ((byte) (0xff & (v >> 24))); + write ((byte) (0xff & (v >> 16))); + write ((byte) (0xff & (v >> 8))); + write ((byte) (0xff & v)); + } + + public final void writeFloat (float v) throws IOException + { + writeInt (Float.floatToIntBits(v)); + } + + public final void writeDouble (double v) throws IOException + { + writeLong (Double.doubleToLongBits(v)); + } + + public final void writeBytes (String s) throws IOException + { + int len = s.length(); + for (int i = 0; i < len; ++i) + writeByte (s.charAt(i)); + } + + public final void writeChars (String s) throws IOException + { + int len = s.length(); + for (int i = 0; i < len; ++i) + writeChar (s.charAt(i)); + } + + public final void writeUTF (String s) throws IOException + { + int len = s.length(); + int sum = 0; + + for (int i = 0; i < len && sum <= 65535; ++i) + { + char c = s.charAt(i); + if (c >= '\u0001' && c <= '\u007f') + sum += 1; + else if (c == '\u0000' || (c >= '\u0080' && c <= '\u07ff')) + sum += 2; + else + sum += 3; + } + + if (sum > 65535) + throw new UTFDataFormatException (); + + writeShort (sum); + + for (int i = 0; i < len; ++i) + { + char c = s.charAt(i); + if (c >= '\u0001' && c <= '\u007f') + write (c); + else if (c == '\u0000' || (c >= '\u0080' && c <= '\u07ff')) + { + write (0xc0 | (0x1f & (c >> 6))); + write (0x80 | (0x3f & c)); + } + else + { + // JSL says the first byte should be or'd with 0xc0, but + // that is a typo. Unicode says 0xe0, and that is what is + // consistent with DataInputStream. + write (0xe0 | (0x0f & (c >> 12))); + write (0x80 | (0x3f & (c >> 6))); + write (0x80 | (0x3f & c)); + } + } + } + + // Number of bytes written so far. + protected int written; +} diff --git a/libjava/java/io/EOFException.java b/libjava/java/io/EOFException.java new file mode 100644 index 00000000000..d890a0f79a7 --- /dev/null +++ b/libjava/java/io/EOFException.java @@ -0,0 +1,34 @@ +// EOFException.java - End of file exception + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class EOFException extends IOException +{ + public EOFException () + { + super (); + } + + public EOFException (String s) + { + super (s); + } +} diff --git a/libjava/java/io/File.java b/libjava/java/io/File.java new file mode 100644 index 00000000000..30d98878f9c --- /dev/null +++ b/libjava/java/io/File.java @@ -0,0 +1,288 @@ +// File.java - File name + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1; 1.2 functionality missing. + * A known bug: most calls to the security manager can generate + * IOException since we use the canonical path. + */ + +public class File implements Serializable +{ + public boolean canRead () + { + return access (checkRead (), READ); + } + + public boolean canWrite () + { + SecurityManager s = System.getSecurityManager(); + String p = safeCanonicalPath (); + // FIXME: it isn't entirely clear what to do if we can't find the + // canonical path. + if (p == null) + return false; + if (s != null) + s.checkWrite(p); + return access (p, WRITE); + } + + private final native boolean performDelete (String canon); + public boolean delete () + { + SecurityManager s = System.getSecurityManager(); + String p = safeCanonicalPath (); + // FIXME: what is right? + if (p == null) + return false; + if (s != null) + s.checkDelete(p); + return performDelete (p); + } + + public boolean equals (Object obj) + { + if (! (obj instanceof File)) + return false; + File other = (File) obj; + return path.compareTo(other.path) == 0; + } + + public boolean exists () + { + return access (checkRead (), EXISTS); + } + + public File (String p) + { + if (p == null) + throw new NullPointerException (); + path = p; + } + + public File (String dirPath, String name) + { + if (name == null) + throw new NullPointerException (); + if (dirPath != null) + { + // Try to be smart about the number of separator characters. + if (dirPath.charAt(dirPath.length() - 1) == separatorChar) + path = dirPath + name; + else + path = dirPath + separatorChar + name; + } + else + path = name; + } + + public File (File dir, String name) + { + this (dir == null ? null : dir.path, name); + } + + public String getAbsolutePath () + { + if (isAbsolute ()) + return path; + return System.getProperty("user.dir") + separatorChar + path; + } + + public native String getCanonicalPath () throws IOException; + + public String getName () + { + int last = path.lastIndexOf(separatorChar); + if (last == -1) + last = 0; + return path.substring(last); + } + + public String getParent () + { + int last = path.lastIndexOf(separatorChar); + if (last == -1) + return null; + return path.substring(0, last); + } + + public String getPath () + { + return path; + } + + public int hashCode () + { + // FIXME: test. + return path.hashCode(); + } + + public native boolean isAbsolute (); + + public boolean isDirectory () + { + return stat (checkRead (), DIRECTORY); + } + + public boolean isFile () + { + return stat (checkRead (), ISFILE); + } + + public long lastModified () + { + return attr (checkRead (), MODIFIED); + } + + public long length () + { + return attr (checkRead (), LENGTH); + } + + private final native String[] performList (String canon, + FilenameFilter filter); + public String[] list (FilenameFilter filter) + { + return performList (checkRead (), filter); + } + + public String[] list () + { + return performList (checkRead (), null); + } + + public String toString () + { + return path; + } + + private final native boolean performMkdir (); + public boolean mkdir () + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + { + // NOTE: in theory we should use the canonical path. In + // practice, we can't compute the canonical path until we've + // made this completely. Lame. + s.checkWrite(path); + } + return performMkdir (); + } + + private static boolean mkdirs (File x) + { + if (x.isDirectory()) + return true; + String p = x.getPath(); + x.setPath(x.getParent()); + if (! mkdirs (x)) + return false; + x.setPath(p); + return x.mkdir(); + } + + public boolean mkdirs () + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + { + // NOTE: in theory we should use the canonical path. In + // practice, we can't compute the canonical path until we've + // made this completely. Lame. + s.checkWrite(path); + } + + if (isDirectory ()) + return false; + return mkdirs (new File (path)); + } + + private final native boolean performRenameTo (File dest); + public boolean renameTo (File dest) + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + { + // FIXME: JCL doesn't specify which path to check. We check the + // source since we can canonicalize it. + s.checkWrite(safeCanonicalPath()); + } + return performRenameTo (dest); + } + + public static final String pathSeparator + = System.getProperty("path.separator"); + public static final char pathSeparatorChar = pathSeparator.charAt(0); + public static final String separator = System.getProperty("file.separator"); + public static final char separatorChar = separator.charAt(0); + + + // The path. + private String path; + + // mkdirs() uses this to avoid repeated allocations. + private final void setPath (String n) + { + path = n; + } + + + private final String checkRead () + { + SecurityManager s = System.getSecurityManager(); + String p = safeCanonicalPath (); + if (p == null) + return null; + if (s != null) + s.checkRead(p); + return p; + } + + // Return canonical path, or null. + private final String safeCanonicalPath () + { + String p = null; + try + { + p = getCanonicalPath (); + } + catch (IOException x) + { + // Nothing. + } + return p; + } + + // QUERY arguments to access function. + private final static int READ = 0; + private final static int WRITE = 1; + private final static int EXISTS = 2; + + // QUERY arguments to stat function. + private final static int DIRECTORY = 0; + private final static int ISFILE = 1; + + // QUERY arguments to attr function. + private final static int MODIFIED = 0; + private final static int LENGTH = 1; + + private final native long attr (String p, int query); + private final native boolean access (String p, int query); + private final native boolean stat (String p, int query); +} diff --git a/libjava/java/io/FileDescriptor.java b/libjava/java/io/FileDescriptor.java new file mode 100644 index 00000000000..0782b0c8e95 --- /dev/null +++ b/libjava/java/io/FileDescriptor.java @@ -0,0 +1,87 @@ +// FileDescriptor.java - Open file or device + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1 + */ + +// For now we assume a POSIXy file system. This can be changed later +// if need be. +public final class FileDescriptor +{ + public static final FileDescriptor in = new FileDescriptor (0); + public static final FileDescriptor out = new FileDescriptor (1); + public static final FileDescriptor err = new FileDescriptor (2); + + public native void sync () throws SyncFailedException; + public native boolean valid (); + + + // These are mode values for open(). + static final int READ = 1; + static final int WRITE = 2; + static final int APPEND = 4; + + // These are WHENCE values for seek. + static final int SET = 0; + static final int CUR = 1; + + // Open a file. MODE is a combination of the above mode flags. + FileDescriptor (String path, int mode) throws IOException + { + fd = open (path, mode); + } + + public FileDescriptor () + { + fd = -1; + } + + native int open (String path, int mode) throws IOException; + native void write (int b) throws IOException; + native void write (byte[] b, int offset, int len) + throws IOException, NullPointerException, IndexOutOfBoundsException; + native void close () throws IOException; + native int seek (long pos, int whence) throws IOException; + native long length () throws IOException; + native long getFilePointer () throws IOException; + native int read () throws IOException; + native int read (byte[] bytes, int offset, int len) throws IOException; + native int available () throws IOException; + + + // When collected, close. + protected void finalize () throws IOException + { + if (valid ()) + close (); + } + + // Attach to an already-opened file. This is not private because we + // need access to it from other packages, for instance java.net. + // Ordinarily that wouldn't work, either, but in our case we know + // the access comes from C++, where "package private" is translated + // into "public". Eww. + FileDescriptor (int desc) + { + fd = desc; + } + + // System's notion of file descriptor. + private int fd; +} diff --git a/libjava/java/io/FileInputStream.java b/libjava/java/io/FileInputStream.java new file mode 100644 index 00000000000..4f44dae03b7 --- /dev/null +++ b/libjava/java/io/FileInputStream.java @@ -0,0 +1,96 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 28, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class FileInputStream extends InputStream +{ + /* Contains the file descriptor for referencing the actual file. */ + private FileDescriptor fd; + + public FileInputStream(String name) throws FileNotFoundException, IOException + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkRead(name); + fd = new FileDescriptor(name, FileDescriptor.READ); + } + + public FileInputStream(File file) throws FileNotFoundException, IOException + { + this(file.getPath()); + } + + public FileInputStream(FileDescriptor fdObj) + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkRead(fdObj); + fd = fdObj; + } + + public int available() throws IOException + { + return fd.available(); + } + + public void close() throws IOException + { + if (fd == null) + return; + + fd.close(); + fd = null; + } + + protected void finalize() throws IOException + { + if (fd != null) + fd.finalize(); + } + + public final FileDescriptor getFD() throws IOException + { + if (!fd.valid()) + throw new IOException(); + return fd; + } + + public int read() throws IOException + { + return fd.read(); + } + + public int read(byte[] b) throws IOException + { + return fd.read(b, 0, b.length); + } + + public int read(byte[] b, int off, int len) throws IOException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + return fd.read(b, off, len); + } + + public long skip(long n) throws IOException + { + return fd.seek(n, FileDescriptor.CUR); + } +} diff --git a/libjava/java/io/FileNotFoundException.java b/libjava/java/io/FileNotFoundException.java new file mode 100644 index 00000000000..07ff9bf1d9b --- /dev/null +++ b/libjava/java/io/FileNotFoundException.java @@ -0,0 +1,34 @@ +// FileNotFoundException.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class FileNotFoundException extends IOException +{ + public FileNotFoundException () + { + super (); + } + + public FileNotFoundException (String s) + { + super (s); + } +} diff --git a/libjava/java/io/FileOutputStream.java b/libjava/java/io/FileOutputStream.java new file mode 100644 index 00000000000..3e6e9724aec --- /dev/null +++ b/libjava/java/io/FileOutputStream.java @@ -0,0 +1,93 @@ +// FileOutputStream.java - Write bytes to a file. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public class FileOutputStream extends OutputStream +{ + public FileOutputStream (String path, boolean append) + throws SecurityException, IOException + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkWrite(path); + fd = new FileDescriptor (path, (append + ? FileDescriptor.APPEND + : FileDescriptor.WRITE)); + } + + public FileOutputStream (String path) throws SecurityException, IOException + { + this (path, false); + } + + public FileOutputStream (File file) throws SecurityException, IOException + { + this (file.getPath(), false); + } + + public FileOutputStream (FileDescriptor fdObj) throws SecurityException + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkWrite(fdObj); + fd = fdObj; + } + + protected void finalize () throws IOException + { + // We don't actually need this, but we include it because it is + // mentioned in the JCL. + } + + public final FileDescriptor getFD () throws IOException + { + if (! fd.valid()) + throw new IOException (); + return fd; + } + + public void write (int b) throws IOException + { + fd.write (b); + } + + public void write (byte[] b) throws IOException, NullPointerException + { + fd.write (b, 0, b.length); + } + + public void write (byte[] b, int off, int len) + throws IOException, NullPointerException, IndexOutOfBoundsException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException (); + fd.write (b, off, len); + } + + public void close () throws IOException + { + if (fd.valid()) + fd.close(); + } + + // Instance variables. + private FileDescriptor fd; +} diff --git a/libjava/java/io/FileReader.java b/libjava/java/io/FileReader.java new file mode 100644 index 00000000000..259526cceff --- /dev/null +++ b/libjava/java/io/FileReader.java @@ -0,0 +1,35 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Per Bothner + * @date April 22, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition. + * Status: Believed complete and correct. + */ + +public class FileReader extends InputStreamReader +{ + public FileReader(String filename) throws IOException + { + super(new FileInputStream(filename)); + } + + public FileReader(File file) throws IOException + { + super(new FileInputStream(file)); + } + + public FileReader(FileDescriptor fd) + { + super(new FileInputStream(fd)); + } +} diff --git a/libjava/java/io/FileWriter.java b/libjava/java/io/FileWriter.java new file mode 100644 index 00000000000..8c3f9a9d303 --- /dev/null +++ b/libjava/java/io/FileWriter.java @@ -0,0 +1,44 @@ +// FileWriter.java - Character output to a file. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public class FileWriter extends OutputStreamWriter +{ + public FileWriter (String fileName) throws IOException + { + super (new FileOutputStream (fileName)); + } + + public FileWriter (String fileName, boolean append) throws IOException + { + super (new FileOutputStream (fileName, append)); + } + + public FileWriter (File file) throws IOException + { + super (new FileOutputStream (file)); + } + + public FileWriter (FileDescriptor fd) + { + super (new FileOutputStream (fd)); + } +} diff --git a/libjava/java/io/FilenameFilter.java b/libjava/java/io/FilenameFilter.java new file mode 100644 index 00000000000..682efed6d8a --- /dev/null +++ b/libjava/java/io/FilenameFilter.java @@ -0,0 +1,26 @@ +// FilenameFilter.java - Compute subset of list of file names + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public interface FilenameFilter +{ + public abstract boolean accept (File dir, String name); +} diff --git a/libjava/java/io/FilterInputStream.java b/libjava/java/io/FilterInputStream.java new file mode 100644 index 00000000000..918948b2edd --- /dev/null +++ b/libjava/java/io/FilterInputStream.java @@ -0,0 +1,75 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 8, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class FilterInputStream extends InputStream +{ + /* The input stream to be filtered. */ + protected InputStream in; + + protected FilterInputStream(InputStream in) + { + this.in = in; + } + + public int available() throws IOException + { + return in.available(); + } + + public void close() throws IOException + { + in.close(); + } + + public synchronized void mark(int readlimit) + { + in.mark(readlimit); + } + + public boolean markSupported() + { + return in.markSupported(); + } + + public int read() throws IOException + { + return in.read(); + } + + public int read(byte[] b) throws IOException + { + return read(b, 0, b.length); + } + + public int read(byte[] b, int off, int len) throws IOException + { + return in.read(b, off, len); + } + + public synchronized void reset() throws IOException + { + in.reset(); + } + + public long skip(long n) throws IOException + { + return in.skip(n); + } +} diff --git a/libjava/java/io/FilterOutputStream.java b/libjava/java/io/FilterOutputStream.java new file mode 100644 index 00000000000..45d6fd024ad --- /dev/null +++ b/libjava/java/io/FilterOutputStream.java @@ -0,0 +1,61 @@ +// FilterOutputStream.java - A filtered stream + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public class FilterOutputStream extends OutputStream +{ + public void close () throws IOException + { + flush (); + out.close(); + } + + public FilterOutputStream (OutputStream ox) + { + out = ox; + } + + public void flush () throws IOException + { + out.flush(); + } + + public void write (int b) throws IOException + { + out.write(b); + } + + public void write (byte[] b) throws IOException, NullPointerException + { + // Don't do checking here, per Java Lang Spec. + out.write (b); + } + + public void write (byte[] b, int off, int len) + throws IOException, NullPointerException, IndexOutOfBoundsException + { + // Don't do checking here, per Java Lang Spec. + out.write(b, off, len); + } + + // The output stream. + protected OutputStream out; +} diff --git a/libjava/java/io/FilterReader.java b/libjava/java/io/FilterReader.java new file mode 100644 index 00000000000..1fe201472b4 --- /dev/null +++ b/libjava/java/io/FilterReader.java @@ -0,0 +1,72 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 15, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public abstract class FilterReader extends Reader +{ + /* The input stream to be filtered. */ + protected Reader in; + + protected FilterReader(Reader in) + { + super(in.lock); + this.in = in; + } + + public void close() throws IOException + { + in.close(); + in = null; + } + + public synchronized void mark(int readlimit) throws IOException + { + in.mark(readlimit); + } + + public boolean markSupported() + { + return in.markSupported(); + } + + public int read() throws IOException + { + return in.read(); + } + + public int read(char[] b, int off, int len) throws IOException + { + return in.read(b, off, len); + } + + public boolean ready() throws IOException + { + return in.ready(); + } + + public synchronized void reset() throws IOException + { + in.reset(); + } + + public long skip(long n) throws IOException + { + return in.skip(n); + } +} diff --git a/libjava/java/io/FilterWriter.java b/libjava/java/io/FilterWriter.java new file mode 100644 index 00000000000..385cc7eee30 --- /dev/null +++ b/libjava/java/io/FilterWriter.java @@ -0,0 +1,59 @@ +// FilterWriter.java - Filtered character output stream. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public abstract class FilterWriter extends Writer +{ + public void close () throws IOException + { + out.close(); + } + + protected FilterWriter (Writer ox) + { + // FIXME: should we really share locks like this? + super (ox); + out = ox; + } + + public void flush () throws IOException + { + out.flush(); + } + + public void write (int oneChar) throws IOException + { + out.write(oneChar); + } + + public void write (char[] buffer, int offset, int count) throws IOException + { + out.write(buffer, offset, count); + } + + public void write (String str, int offset, int count) throws IOException + { + out.write(str, offset, count); + } + + // Where our writes should go. + protected Writer out; +} diff --git a/libjava/java/io/IOException.java b/libjava/java/io/IOException.java new file mode 100644 index 00000000000..15a14ff15fa --- /dev/null +++ b/libjava/java/io/IOException.java @@ -0,0 +1,34 @@ +// IOException.java - Base class for I/O Exceptions + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class IOException extends Exception +{ + public IOException () + { + super (); + } + + public IOException (String s) + { + super (s); + } +} diff --git a/libjava/java/io/InputStream.java b/libjava/java/io/InputStream.java new file mode 100644 index 00000000000..cc86efd49d6 --- /dev/null +++ b/libjava/java/io/InputStream.java @@ -0,0 +1,104 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public abstract class InputStream +{ + public InputStream() + { + } + + public int available() throws IOException + { + return 0; + } + + public void close() throws IOException + { + // Do nothing + } + + public void mark(int readlimit) + { + // Do nothing + } + + public boolean markSupported() + { + return false; + } + + public abstract int read() throws IOException; + + public int read(byte[] b) throws IOException + { + return read(b, 0, b.length); + } + + public int read(byte[] b, int off, int len) throws IOException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new IndexOutOfBoundsException(); + if (b.length == 0) + return 0; + + int i, ch; + + for (i = 0; i < len; ++i) + try + { + if ((ch = read()) < 0) + return i == 0 ? -1 : i; // EOF + b[off + i] = (byte) ch; + } + catch (IOException ex) + { + // Only reading the first byte should cause an IOException. + if (i == 0) + throw ex; + return i; + } + + return i; + } + + public void reset() throws IOException + { + throw new IOException("mark/reset not supported"); + } + + public long skip(long n) throws IOException + { + // Throw away n bytes by reading them into a temp byte[]. + // Limit the temp array to 2Kb so we don't grab too much memory. + final int buflen = n > 2048 ? 2048 : (int) n; + byte[] tmpbuf = new byte[buflen]; + final long origN = n; + + while (n > 0L) + { + int numread = read(tmpbuf, 0, n > buflen ? buflen : (int) n); + if (numread <= 0) + break; + n -= numread; + } + + return origN - n; + } +} diff --git a/libjava/java/io/InputStreamReader.java b/libjava/java/io/InputStreamReader.java new file mode 100644 index 00000000000..ee44f918122 --- /dev/null +++ b/libjava/java/io/InputStreamReader.java @@ -0,0 +1,151 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; +import gnu.gcj.convert.*; + +/** + * @author Per Bothner + * @date April 22, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct, but only supports 8859_1. + */ + +public class InputStreamReader extends Reader +{ + BufferedInputStream in; + + // Buffer of chars read from in and converted but not consumed. + char[] work; + // Next available character (in work buffer) to read. + int wpos; + // Last available character (in work buffer) to read. + int wcount; + + BytesToUnicode converter; + + public InputStreamReader(InputStream in) + { + this(in, BytesToUnicode.getDefaultDecoder()); + } + + public InputStreamReader(InputStream in, String enc) + throws UnsupportedEncodingException + { + this(in, BytesToUnicode.getDecoder(enc)); + } + + private InputStreamReader(InputStream in, BytesToUnicode decoder) + { + super(in); + this.in = in instanceof BufferedInputStream ? (BufferedInputStream) in + : new BufferedInputStream(in, 250); + converter = decoder; + converter.setInput(this.in.buf, 0, 0); + } + + public void close() throws IOException + { + synchronized (lock) + { + if (in != null) + in.close(); + in = null; + work = null; + wpos = wcount = 0; + } + } + + public String getEncoding() { return converter.getName(); } + + public boolean ready() throws IOException + { + synchronized (lock) + { + if (wpos < wcount) + return true; + if (work == null) + { + work = new char[100]; + wpos = 0; + wcount = 0; + } + for (;;) + { + if (in.available() <= 0) + return false; + in.mark(1); + int b = in.read(); + if (b < 0) + return true; + in.reset(); + converter.setInput(in.buf, in.pos, in.count); + wpos = 0; + wcount = converter.read(work, 0, work.length); + in.skip(converter.inpos - in.pos); + if (wcount > 0) + return true; + } + } + } + + public int read(char buf[], int offset, int length) throws IOException + { + synchronized (lock) + { + int wavail = wcount - wpos; + if (wavail > 0) + { + if (length > wavail) + length = wavail; + System.arraycopy(work, wpos, buf, offset, length); + wpos += length; + return length; + } + else + { + for (;;) + { + in.mark(1); + int b = in.read(); + if (b < 0) + return -1; + in.reset(); + converter.setInput(in.buf, in.pos, in.count); + int count = converter.read (buf, offset, length); + in.skip(converter.inpos - in.pos); + if (count > 0) + return count; + } + } + } + } + + public int read() throws IOException + { + synchronized (lock) + { + int wavail = wcount - wpos; + if (wavail > 0) + return work[wpos++]; + if (work == null) + { + work = new char[100]; + wpos = 0; + wcount = 0; + } + int count = read(work, wpos, work.length-wpos); + if (count <= 0) + return -1; + wcount = wpos + count; + return work[wpos++]; + } + } +} diff --git a/libjava/java/io/InterruptedIOException.java b/libjava/java/io/InterruptedIOException.java new file mode 100644 index 00000000000..11d922b765e --- /dev/null +++ b/libjava/java/io/InterruptedIOException.java @@ -0,0 +1,36 @@ +// InterruptedIOException.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class InterruptedIOException extends IOException +{ + public InterruptedIOException () + { + super (); + } + + public InterruptedIOException (String s) + { + super (s); + } + + public int bytesTransferred = 0; +} diff --git a/libjava/java/io/LineNumberInputStream.java b/libjava/java/io/LineNumberInputStream.java new file mode 100644 index 00000000000..1b96da9c846 --- /dev/null +++ b/libjava/java/io/LineNumberInputStream.java @@ -0,0 +1,143 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date November 11, 1998. + * @deprecated + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. Deprecated in JDK 1.1. + */ + +public class LineNumberInputStream extends FilterInputStream +{ + /* The current line number. */ + private int lineNumber = 0; + + /* The line number when the stream was marked. */ + private int markLineNumber = 0; + + /* Flag to indicate a '\r' was just read so that an immediately subsequent + * '\n' can be ignored. */ + private boolean justReadReturnChar = false; + + public LineNumberInputStream(InputStream in) + { + super(in); + } + + public int available() throws IOException + { + // We can only guarantee half the characters that might be available + // without blocking because "\r\n" is treated as a single character. + return in.available() / 2; + } + + public int getLineNumber() + { + return lineNumber; + } + + public void mark(int readlimit) + { + in.mark(readlimit); + markLineNumber = lineNumber; + } + + public int read() throws IOException + { + // Treat "\r\n" as a single character. A '\r' may have been read by + // a previous call to read so we keep an internal flag to avoid having + // to read ahead. + + int ch = in.read(); + + if (ch == '\n') + if (justReadReturnChar) + { + ch = in.read(); + justReadReturnChar = false; + } + else + lineNumber++; + else if (ch == '\r') + { + ch = '\n'; + justReadReturnChar = true; + lineNumber++; + } + else + justReadReturnChar = false; + + return ch; + } + + public int read(byte[] b, int off, int len) throws IOException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + // This case always succeeds. + if (len == 0) + return 0; + + // The simplest, though not necessarily the most time efficient thing + // to do is simply call read(void) len times. Since this is a deprecated + // class, that should be ok. + final int origOff = off; + while (len-- > 0) + { + int ch = read(); + if (ch < 0) + break; + + b[off++] = (byte) ch; + } + + // This is safe since we already know that some bytes were + // actually requested. + return off == origOff ? -1 : off - origOff; + } + + public void reset() throws IOException + { + in.reset(); + lineNumber = markLineNumber; + justReadReturnChar = false; + } + + public void setLineNumber(int lineNumber) + { + this.lineNumber = lineNumber; + } + + public long skip(long n) throws IOException + { + if (n <= 0) + return 0L; + + final long origN = n; + + do + { + int ch = read(); + if (ch < 0) + break; + if (ch == '\n' || ch == '\r') + lineNumber++; + } + while (--n > 0); + + return origN - n; + } +} diff --git a/libjava/java/io/LineNumberReader.java b/libjava/java/io/LineNumberReader.java new file mode 100644 index 00000000000..c709a7a0079 --- /dev/null +++ b/libjava/java/io/LineNumberReader.java @@ -0,0 +1,245 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Per Bothner + * @date April 22, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + * + * This implementation has the feature that if '\r' is read, it + * does not look for a '\n', but immediately returns '\n'. + * On the next read(), if a '\n' is read, it is skipped. + * This has the advantage that we do not read (and hang) unnecessarily. + * + * This implementation is also minimal in the number of fields it uses. + */ + +public class LineNumberReader extends BufferedReader +{ + /** The current line number. */ + int lineNumber; + + public LineNumberReader(Reader in) + { + super(in, 8192); + } + + public LineNumberReader(Reader in, int size) + { + super(in, size); + } + + public int getLineNumber() + { + return lineNumber; + } + + public void setLineNumber(int lineNumber) + { + this.lineNumber = lineNumber; + } + + private static int countLines (char[] buffer, int off, int len) + { + int count = 0; + char prev = '\0'; + for (int i = 0; i < len; i++) + { + char ch = buffer[i+off]; + if ((ch == '\n' && prev != '\r') || ch == '\r') + count++; + prev = ch; + } + return count; + } + + public void mark(int readLimit) throws IOException + { + synchronized (lock) + { + // This is basically the same as BufferedReader.mark. + // However, if the previous character was a '\r', we need to + // save that 'r', in case the next character is a '\n'. + if (pos + readLimit > limit) + { + int saveCR = (pos > 0 && buffer[pos-1] == '\r') ? 1 : 0; + char[] old_buffer = buffer; + if (readLimit > limit) + buffer = new char[saveCR + readLimit]; + int copy_start = pos - saveCR; + limit -= copy_start; + System.arraycopy(old_buffer, copy_start, buffer, 0, limit); + pos = saveCR; + } + markPos = pos; + } + } + + public void reset() throws IOException + { + synchronized (lock) + { + if (markPos < 0) + throw new IOException("mark never set or invalidated"); + if (markPos > 0 && pos > markPos && buffer[markPos-1] == '\r' + && buffer[markPos] == '\n') + lineNumber--; + lineNumber -= countLines(buffer, pos, markPos); + pos = markPos; + } + } + + public int read() throws IOException + { + synchronized (lock) + { + skipRedundantLF(); + if (pos >= limit) + { + if (markPos >= 0 && limit == buffer.length) + markPos = -1; + if (markPos <= 0) + pos = limit = 0; + int count = in.read(buffer, limit, buffer.length - limit); + if (count <= 0) + return -1; + limit += count; + } + char ch = buffer[pos++]; + if (ch == '\r' || ch == '\n') + { + lineNumber++; + return '\n'; + } + return (int) ch; + } + } + + public int read(char[] buf, int offset, int count) throws IOException + { + if (count <= 0) + { + if (count < 0) + throw new IndexOutOfBoundsException(); + return 0; + } + synchronized (lock) + { + int first = read(); + if (first < 0) + return -1; + int start_offset = offset; + buf[offset++] = (char) first; + if (buffer[pos-1] == '\r' && pos < limit && buffer[pos] == '\n') + pos++; + count--; + while (count-- > 0 && pos < limit) + { + char ch = buffer[pos++]; + if (ch == '\r') + { + lineNumber++; + ch = '\n'; + if (pos < limit && buffer[pos] == '\n') + pos++; + } + else if (ch == '\n') + lineNumber++; + buf[offset++] = ch; + } + return offset - start_offset; + } + } + + private void skipRedundantLF() throws IOException + { + if (pos > 0 && buffer[pos-1] == '\r') + { + if (pos < limit) + { // fast case + if (buffer[pos] == '\n') + pos++; + } + else + { // use read() to deal with the general case. + // Set pos and limit to zero to avoid infinite recursion in read. + // May need to invalidate markPos if we've exceeded the buffer. + if (pos >= buffer.length) + markPos = -1; + pos = limit = 0; + int ch = read(); + if (ch >= 0 && ch != '\n') + pos--; + } + } + } + + public String readLine() throws IOException + { + // BufferedReader.readLine already does this. Shouldn't need to keep + // track of newlines (since the read method deals with this for us). + // But if the buffer is large, we may not call the read method at all + // and super.readLine can't increment lineNumber itself. + // Though it may seem kludgy, the safest thing to do is to save off + // lineNumber and increment it explicitly when we're done (iff we + // ended with a '\n' or '\r' as opposed to EOF). + // + // Also, we need to undo the special casing done by BufferedReader.readLine + // when a '\r' is the last char in the buffer. That situation is marked + // by 'pos > limit'. + int tmpLineNumber = lineNumber; + skipRedundantLF(); + String str = super.readLine(); + if (pos > limit) + --pos; + + int ch; + if (pos > 0 && ((ch = buffer[pos - 1]) == '\n' || ch == '\r')) + lineNumber = tmpLineNumber + 1; + + return str; + } + + public long skip(long count) throws IOException + { + if (count <= 0) + return 0; + long to_do = count; + do + { + int ch = read(); + if (ch < 0) + break; + to_do--; + if (ch == '\n' || ch == '\r') + lineNumber++; + else + { + long fence = pos + to_do; + if (limit < fence) + fence = limit; + int end = pos; + for (; end < fence; end++) + { + char endch = buffer[end]; + if (endch == '\n' || endch == '\r') + break; + } + to_do -= end - pos; + pos = end; + } + } + while (to_do > 0); + return count - to_do; + } +} diff --git a/libjava/java/io/OutputStream.java b/libjava/java/io/OutputStream.java new file mode 100644 index 00000000000..5aae3611621 --- /dev/null +++ b/libjava/java/io/OutputStream.java @@ -0,0 +1,48 @@ +// OutputStream.java - Send output bytes to output sink. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to version 1.1. + */ + +public abstract class OutputStream +{ + public abstract void write (int b) throws IOException; + + public void write (byte[] b) throws IOException, NullPointerException + { + write (b, 0, b.length); + } + + public void write (byte[] b, int off, int len) + throws IOException, NullPointerException, IndexOutOfBoundsException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException (); + for (int i = 0; i < len; ++i) + write (b[off + i]); + } + + public void flush () throws IOException + { + } + + public void close () throws IOException + { + } +} diff --git a/libjava/java/io/OutputStreamWriter.java b/libjava/java/io/OutputStreamWriter.java new file mode 100644 index 00000000000..e529474875c --- /dev/null +++ b/libjava/java/io/OutputStreamWriter.java @@ -0,0 +1,155 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; +import gnu.gcj.convert.UnicodeToBytes; + +/** + * @author Per Bothner + * @date April 17, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct, but only supports 8859_1. + */ + +public class OutputStreamWriter extends Writer +{ + BufferedOutputStream out; + + UnicodeToBytes converter; + + /* Temporary buffer. */ + private char[] work; + private int wcount; + + public String getEncoding() { return converter.getName(); } + + private OutputStreamWriter(OutputStream out, UnicodeToBytes encoder) + { + super(out); + this.out = out instanceof BufferedOutputStream ? (BufferedOutputStream) out + : new BufferedOutputStream(out, 2048); + this.converter = encoder; + } + + public OutputStreamWriter(OutputStream out, String enc) + throws UnsupportedEncodingException + { + this(out, UnicodeToBytes.getEncoder(enc)); + } + + public OutputStreamWriter(OutputStream out) + { + this(out, UnicodeToBytes.getDefaultEncoder()); + } + + public void close() throws IOException + { + synchronized (lock) + { + flush(); + if (out != null) + { + out.close(); + out = null; + } + work = null; + } + } + + public void flush() throws IOException + { + synchronized (lock) + { + if (wcount > 0) + { + writeChars(work, 0, wcount); + wcount = 0; + } + out.flush(); + } + } + + public void write(char[] buf, int offset, int count) + throws IOException + { + synchronized (lock) + { + if (wcount > 0) + { + writeChars(work, 0, wcount); + wcount = 0; + } + writeChars(buf, offset, count); + } + } + + private void writeChars(char[] buf, int offset, int count) + throws IOException + { + while (count > 0) + { + if (out.count != 0) + { + out.flush(); + if (out.count != 0) + throw new IOException("unable to flush output byte buffer"); + } + converter.setOutput(out.buf, out.count); + int converted = converter.write(buf, offset, count); + offset += converted; + count -= converted; + out.count = converter.count; + } + } + + public void write(String str, int offset, int count) + throws IOException + { + synchronized (lock) + { + if (work == null) + work = new char[100]; + int wlength = work.length; + while (count > 0) + { + int size = count; + if (wcount + size > wlength) + { + if (2*wcount > wlength) + { + writeChars(work, 0, wcount); + wcount = 0; + } + if (wcount + size > wlength) + size = wlength - wcount; + } + str.getChars(offset, offset+size, work, wcount); + offset += size; + count -= size; + wcount += size; + } + } + } + + public void write(int ch) throws IOException + { + synchronized (lock) + { + if (work == null) + work = new char[100]; + if (wcount >= work.length) + { + writeChars(work, 0, wcount); + wcount = 0; + } + work[wcount++] = (char) ch; + } + } +} diff --git a/libjava/java/io/PipedInputStream.java b/libjava/java/io/PipedInputStream.java new file mode 100644 index 00000000000..d8a836c289f --- /dev/null +++ b/libjava/java/io/PipedInputStream.java @@ -0,0 +1,242 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 29, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class PipedInputStream extends InputStream +{ + /* The size of the pipe's circular input buffer. */ + protected static final int PIPE_SIZE = 1024; + + /* The circular buffer into which incoming data is placed. */ + protected byte[] buffer; + + /* The index in the buffer at which the next byte of data will be stored. */ + protected int in = -1; + + /* The index in the buffer at which the next byte of data will be read. */ + protected int out = 0; + + /* The output stream this is connected to; used to check for errors. */ + private PipedOutputStream po = null; + + /* Flag to indicate that the output stream was closed. */ + private boolean outClosed = false; + + public PipedInputStream(PipedOutputStream src) throws IOException + { + buffer = new byte[PIPE_SIZE]; + connect(src); + } + + public PipedInputStream() + { + buffer = new byte[PIPE_SIZE]; + } + + public synchronized int available() throws IOException + { + if (in < 0) + return 0; + + if (in > out) + return in - out; + + // Buffer has wrapped around. + return buffer.length - out + in; + } + + public void close() throws IOException + { + buffer = null; + po = null; + + // Mark as empty for available method. + in = -1; + } + + public void connect(PipedOutputStream src) throws IOException + { + if (buffer == null) + throw new IOException("pipe closed"); + + if (po != null) + if (po == src) + return; + else + throw new IOException("pipe already connected"); + + po = src; + try + { + src.connect(this); + } + catch (IOException ex) + { + po = null; + throw ex; + } + } + + public synchronized int read() throws IOException + { + // TBD: Spec says to throw IOException if thread writing to output stream + // died. What does this really mean? Theoretically, multiple threads + // could be writing to this object. Do you track the first, last, or + // all of them? + if (po == null) + if (buffer == null) + throw new IOException("pipe closed"); + else + throw new IOException("pipe unconnected"); + + // Block until there's something to read or output stream was closed. + while (in < 0) + try + { + if (outClosed) + return -1; + wait(); + } + catch (InterruptedException ex) + { + throw new InterruptedIOException(); + } + + // Let other threads know there's room to write now. + notifyAll(); + + int retval = buffer[out++] & 0xFF; + + // Wrap back around if at end of the array. + if (out >= buffer.length) + out = 0; + + // When the last byte available is read, mark the buffer as empty. + if (out == in) + { + in = -1; + out = 0; + } + + return retval; + } + + public synchronized int read(byte[] b, int off, int len) throws IOException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + // TBD: Spec says to throw IOException if thread writing to output stream + // died. What does this really mean? Theoretically, multiple threads + // could be writing to this object. Do you track the first, last, or + // all of them? + if (po == null) + if (buffer == null) + throw new IOException("pipe closed"); + else + throw new IOException("pipe unconnected"); + + // Block until there's something to read or output stream was closed. + while (in < 0) + try + { + if (outClosed) + return -1; + wait(); + } + catch (InterruptedException ex) + { + throw new InterruptedIOException(); + } + + // Let other threads know there's room to write now. + notifyAll(); + + int numRead; + len = Math.min(len, available()); + if (in <= out && len >= (numRead = buffer.length - out)) + { + // Buffer has wrapped around; need to copy in 2 steps. + // Copy to the end of the buffer first; second copy may be of zero + // bytes but that is ok. Doing it that way saves having to check + // later if 'out' has grown to buffer.length. + System.arraycopy(buffer, out, b, off, numRead); + len -= numRead; + off += numRead; + out = 0; + } + else + numRead = 0; + + System.arraycopy(buffer, out, b, off, len); + numRead += len; + out += len; + + // When the last byte available is read, mark the buffer as empty. + if (out == in) + { + in = -1; + out = 0; + } + + return numRead; + } + + protected synchronized void receive(int b) throws IOException + { + if (buffer == null) + throw new IOException("pipe closed"); + + // TBD: Spec says to throw IOException if thread reading from input stream + // died. What does this really mean? Theoretically, multiple threads + // could be reading to this object (why else would 'read' be synchronized?). + // Do you track the first, last, or all of them? + + if (b < 0) + { + outClosed = true; + notifyAll(); // In case someone was blocked in a read. + return; + } + + // Block until there's room in the pipe. + while (in == out) + try + { + wait(); + } + catch (InterruptedException ex) + { + throw new InterruptedIOException(); + } + + // Check if buffer is empty. + if (in < 0) + in = 0; + + buffer[in++] = (byte) b; + + // Wrap back around if at end of the array. + if (in >= buffer.length) + in = 0; + + // Let other threads know there's something to read when this returns. + notifyAll(); + } +} diff --git a/libjava/java/io/PipedOutputStream.java b/libjava/java/io/PipedOutputStream.java new file mode 100644 index 00000000000..9b069944926 --- /dev/null +++ b/libjava/java/io/PipedOutputStream.java @@ -0,0 +1,94 @@ +// PipedOutputStream.java - Write bytes to a pipe. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Believed complete and correct. + */ + +public class PipedOutputStream extends OutputStream +{ + public void close () throws IOException + { + closed = true; + + // Notify PipedInputStream that there is no more data to be had. + destination.receive(-1); + } + + public void connect (PipedInputStream dest) throws IOException + { + if (closed) + throw new IOException("pipe closed"); + + if (destination != null) + if (destination == dest) + return; + else + throw new IOException("pipe already connected"); + + destination = dest; + try + { + dest.connect(this); + } + catch (IOException ex) + { + destination = null; + throw ex; + } + } + + public synchronized void flush () throws IOException + { + // There doesn't seem to be anything to do here. + + // TBD: Should this maybe do a notifyAll as a way for the user + // to wake up the input stream to check for bytes to read? Shouldn't + // be necessary but if there aren't any bytes, other threads will just + // go blocak again anyway so it wouldn't hurt. + } + + public PipedOutputStream () + { + closed = false; + } + + public PipedOutputStream (PipedInputStream dest) throws IOException + { + closed = false; + connect (dest); + } + + public void write (int oneByte) throws IOException + { + if (closed) + throw new IOException (); + destination.receive(oneByte); + } + + // This is mentioned in the JCL book, but we don't really need it. + // If there were a corresponding receive() method on + // PipedInputStream then we could get better performance using + // this. + // public void write (byte[] buffer, int offset, int count) + // throws IOException; + + // Instance variables. + private PipedInputStream destination; + private boolean closed; +} diff --git a/libjava/java/io/PipedReader.java b/libjava/java/io/PipedReader.java new file mode 100644 index 00000000000..f54c4f8031f --- /dev/null +++ b/libjava/java/io/PipedReader.java @@ -0,0 +1,210 @@ +// PipedReader.java - Piped character stream. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class PipedReader extends Reader +{ + public void close () throws IOException + { + closed = true; + } + + public void connect (PipedWriter src) throws IOException + { + if (closed) + throw new IOException ("already closed"); + if (writer != null) + { + if (writer == src) + return; + throw new IOException ("already connected"); + } + try + { + writer = src; + writer.connect(this); + } + catch (IOException e) + { + writer = null; + throw e; + } + } + + public PipedReader () + { + super (); + writer = null; + closed = false; + in = -1; + out = 0; + pipeBuffer = new char[1024]; + } + + public PipedReader (PipedWriter src) throws IOException + { + super (); + closed = false; + in = -1; + out = 0; + pipeBuffer = new char[1024]; + connect (src); + } + + public int read (char buf[], int offset, int count) throws IOException + { + if (closed) + throw new IOException ("closed"); + if (count < 0) + throw new ArrayIndexOutOfBoundsException (); + int toCopy = count; + synchronized (lock) + { + while (toCopy > 0) + { + // Wait for data in the pipe. If the writer is closed and + // no data has been copied into the output buffer, return + // the magic EOF number. + while (in == -1) + { + if (writer.isClosed()) + { + if (toCopy < count) + return count - toCopy; + return -1; + } + + // Note that JCL doesn't say this is the right thing + // to do. Still, it feels right, and we must deal + // with an interrupt somehow. + try + { + lock.wait(); + } + catch (InterruptedException e) + { + InterruptedIOException io + = new InterruptedIOException (e.getMessage()); + io.bytesTransferred = count - toCopy; + throw io; + } + } + // Now copy some data from pipe into user buffer. + int len; + if (in < out) + len = pipeBuffer.length - out; + else + len = in - out; + len = len > toCopy ? toCopy : len; + System.arraycopy(pipeBuffer, out, buf, offset, len); + out += len; + if (out == pipeBuffer.length) + out = 0; + toCopy -= len; + offset += len; + // If we've read all the data, then reset so that we know + // there is nothing left to be read. + if (in == out) + in = -1; + // Tell anybody waiting for space in the buffer. + lock.notifyAll(); + } + } + return count; + } + + void receive (char buf[], int offset, int count) throws IOException + { + if (count < 0) + throw new ArrayIndexOutOfBoundsException (); + int original = count; + synchronized (lock) + { + while (count > 0) + { + // Wait until there is some space in the buffer. + while (in == out) + { + try + { + lock.wait(); + } + catch (InterruptedException e) + { + // Turn interrupts into IO interrupts. + InterruptedIOException io + = new InterruptedIOException (e.getMessage()); + io.bytesTransferred = original - count; + throw io; + } + } + + // Compute destination in the pipe. + int base, len; + if (in == -1) + { + base = 0; + len = pipeBuffer.length; + } + else if (in < out) + { + base = in; + len = out - in; + } + else + { + base = in; + len = pipeBuffer.length - in; + } + int copyLen = len > count ? count : len; + // Copy data and update local state. + System.arraycopy(buf, offset, pipeBuffer, base, copyLen); + in = base + copyLen; + if (in == pipeBuffer.length) + in = 0; + count -= copyLen; + offset += copyLen; + // Tell anybody waiting for data. + lock.notifyAll(); + } + } + } + + + boolean isClosed () + { + return closed; + } + + // The associated writer. + private PipedWriter writer; + // True if this reader has been closed. + boolean closed; + + // Index of next character to overwrite when receive() is called. + // If -1, then that means the buffer is empty. + private int in; + // Index of next character to return from read(). + private int out; + + // The pipe buffer itself. + private char[] pipeBuffer; +} diff --git a/libjava/java/io/PipedWriter.java b/libjava/java/io/PipedWriter.java new file mode 100644 index 00000000000..c914cac9f9c --- /dev/null +++ b/libjava/java/io/PipedWriter.java @@ -0,0 +1,88 @@ +// PipedWriter.java - Piped character stream. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class PipedWriter extends Writer +{ + public void close () throws IOException + { + closed = true; + } + + public void connect (PipedReader sink) throws IOException + { + if (closed) + throw new IOException ("already closed"); + if (reader != null) + { + if (reader == sink) + return; + throw new IOException ("already connected"); + } + try + { + reader = sink; + reader.connect(this); + } + catch (IOException e) + { + reader = null; + throw e; + } + } + + public void flush () throws IOException + { + // We'll throw an exception if we're closed, but there's nothing + // else to do here. + if (closed) + throw new IOException ("closed"); + } + + public PipedWriter () + { + super (); + closed = false; + } + + public PipedWriter (PipedReader sink) throws IOException + { + super (); + closed = false; + connect (sink); + } + + public void write (char buffer[], int offset, int count) throws IOException + { + if (closed) + throw new IOException ("closed"); + reader.receive(buffer, offset, count); + } + + boolean isClosed () + { + return closed; + } + + // The associated reader. + private PipedReader reader; + private boolean closed; +} diff --git a/libjava/java/io/PrintStream.java b/libjava/java/io/PrintStream.java new file mode 100644 index 00000000000..499e5eb7059 --- /dev/null +++ b/libjava/java/io/PrintStream.java @@ -0,0 +1,236 @@ +// PrintStream.java - Print string representations + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Not finished. + */ + +public class PrintStream extends FilterOutputStream +{ + public boolean checkError () + { + return error; + } + + public void close () + { + try + { + out.close(); + } + catch (IOException e) + { + setError (); + } + } + + public void flush () + { + try + { + out.flush(); + } + catch (IOException e) + { + setError (); + } + } + + private final void print (String str, boolean check_term) + { + try + { + write(str.getBytes()); + if (check_term + && auto_flush + && str.indexOf(line_separator) != -1) + flush (); + } + catch (IOException e) + { + setError (); + } + } + + public void print (boolean bool) + { + print (String.valueOf(bool), false); + } + + public void print (int inum) + { + print (String.valueOf(inum), false); + } + + public void print (long lnum) + { + print (String.valueOf(lnum), false); + } + + public void print (float fnum) + { + print (String.valueOf(fnum), false); + } + + public void print (double dnum) + { + print (String.valueOf(dnum), false); + } + + public void print (Object obj) + { + print (String.valueOf(obj), false); + } + + public void print (String str) + { + print (str, true); + } + + public void print (char ch) + { + print (String.valueOf(ch), true); + } + + public void print (char[] charArray) + { + print (String.valueOf(charArray), true); + } + + public void println () + { + print (line_separator, false); + if (auto_flush) + flush (); + } + + public void println (boolean bool) + { + print (String.valueOf(bool), false); + println (); + } + + public void println (int inum) + { + print (String.valueOf(inum), false); + println (); + } + + public void println (long lnum) + { + print (String.valueOf(lnum), false); + println (); + } + + public void println (float fnum) + { + print (String.valueOf(fnum), false); + println (); + } + + public void println (double dnum) + { + print (String.valueOf(dnum), false); + println (); + } + + public void println (Object obj) + { + print (String.valueOf(obj), false); + println (); + } + + public void println (String str) + { + print (str, false); + println (); + } + + public void println (char ch) + { + print (String.valueOf(ch), false); + println (); + } + + public void println (char[] charArray) + { + print (String.valueOf(charArray), false); + println (); + } + + public PrintStream (OutputStream out) + { + super (out); + error = false; + auto_flush = false; + } + + public PrintStream (OutputStream out, boolean af) + { + super (out); + error = false; + auto_flush = af; + } + + protected void setError () + { + error = true; + } + + public void write (int oneByte) + { + try + { + out.write(oneByte); + // JCL says to do this. I think it is wrong. FIXME. + if (auto_flush && oneByte == '\n') + out.flush(); + } + catch (IOException e) + { + setError (); + } + } + + public void write (byte[] buffer, int offset, int count) + { + try + { + out.write(buffer, offset, count); + // FIXME: JCL says to flush. But elsewhere the JCL says to + // use write to write the stringified form of an object, and + // only to flush if that string contains the line separator. + // How to resolve the contradiction? + if (auto_flush) + out.flush(); + } + catch (IOException e) + { + setError (); + } + } + + // True if error occurred. + private boolean error; + // True if auto-flush. + private boolean auto_flush; + + // Line separator string. + private static final String line_separator + = System.getProperty("line.separator"); +} diff --git a/libjava/java/io/PrintWriter.java b/libjava/java/io/PrintWriter.java new file mode 100644 index 00000000000..2a6cb01b95b --- /dev/null +++ b/libjava/java/io/PrintWriter.java @@ -0,0 +1,286 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Per Bothner + * @date April 17, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + * However, should use native methods for conversion. + */ + +public class PrintWriter extends Writer +{ + private boolean autoflush; + private boolean error; + Writer out; + + public PrintWriter(Writer wr) + { + super(wr); + this.out = wr; + } + + public PrintWriter(Writer wr, boolean autoflush) + { + super(wr); + this.out = wr; + this.autoflush = autoflush; + } + + public PrintWriter(OutputStream out) + { + super(); + this.out = new OutputStreamWriter(out); + this.lock = this.out; + } + + public PrintWriter(OutputStream out, boolean autoflush) + { + this(out); + this.autoflush = autoflush; + } + protected void setError() { error = true; } + + public boolean checkError() + { + flush(); + return error; + } + + public void flush() + { + try + { + out.flush(); + } + catch (IOException ex) + { + error = true; + } + } + + public void close() + { + try + { + out.close(); + } + catch (IOException ex) + { + error = true; + } + } + + public void print(String str) + { + try + { + out.write(str == null ? "null" : str); + } + catch (IOException ex) + { + error = true; + } + } + + public void print(char ch) + { + write((int) ch); + } + + public void print(char[] charArray) + { + write(charArray, 0, charArray.length); + } + + public void print(boolean bool) + { + print(bool ? "true" : "false"); + } + + public void print(int inum) + { + print(Integer.toString(inum)); + } + + public void print(long lnum) + { + print(Long.toString(lnum)); + } + + public void print(float fnum) + { + print(Float.toString(fnum)); + } + + public void print(double dnum) + { + print(Double.toString(dnum)); + } + + public void print(Object obj) + { + print(obj == null ? "null" : obj.toString()); + } + + private static final char[] line_separator + = System.getProperty("line.separator").toCharArray(); + + public void println() + { + synchronized (lock) + { + printlnUnsynchronized(); + } + } + + private void printlnUnsynchronized() + { + try + { + write(line_separator, 0, line_separator.length); + if (autoflush) + out.flush(); + } + catch (IOException ex) + { + error = true; + } + } + + public void println(boolean bool) + { + synchronized (lock) + { + print(bool); + printlnUnsynchronized(); + } + } + public void println(int inum) + { + synchronized (lock) + { + print(inum); + printlnUnsynchronized(); + } + } + + public void println(long lnum) + { + synchronized (lock) + { + print(lnum); + printlnUnsynchronized(); + } + } + + public void println(float fnum) + { + synchronized (lock) + { + print(fnum); + printlnUnsynchronized(); + } + } + + public void println(double dnum) + { + synchronized (lock) + { + print(dnum); + printlnUnsynchronized(); + } + } + + public void println(Object obj) + { + synchronized (lock) + { + print(obj); + printlnUnsynchronized(); + } + } + + public void println(String str) + { + synchronized (lock) + { + print(str); + printlnUnsynchronized(); + } + } + + public void println(char ch) + { + synchronized (lock) + { + print(ch); + printlnUnsynchronized(); + } + } + + public void println(char[] charArray) + { + synchronized (lock) + { + print(charArray); + printlnUnsynchronized(); + } + } + + public void write(int ch) + { + try + { + out.write(ch); + } + catch (IOException ex) + { + error = true; + } + } + + public void write(char[] charArray, int offset, int count) + { + try + { + out.write(charArray, offset, count); + } + catch (IOException ex) + { + error = true; + } + } + + public void write(String str, int offset, int count) + { + try + { + out.write(str, offset, count); + } + catch (IOException ex) + { + error = true; + } + } + + public void write(char[] charArray) + { + write(charArray, 0, charArray.length); + } + + public void write(String str) + { + write(str, 0, str.length()); + } +} diff --git a/libjava/java/io/PushbackInputStream.java b/libjava/java/io/PushbackInputStream.java new file mode 100644 index 00000000000..58c8fe6c4ec --- /dev/null +++ b/libjava/java/io/PushbackInputStream.java @@ -0,0 +1,124 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 15, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class PushbackInputStream extends FilterInputStream +{ + /* Internal buffer array for data. */ + protected byte[] buf; + + /* The current position in the buffer. */ + protected int pos; + + public PushbackInputStream(InputStream in) + { + this(in, 1); + } + + public PushbackInputStream(InputStream in, int size) + { + super(in); + if (size < 0) + throw new IllegalArgumentException(); + buf = new byte[size]; + pos = buf.length; + } + + public int available() throws IOException + { + return pos + super.available(); + } + + public void close() throws IOException + { + buf = null; + super.close(); + } + + public boolean markSupported() + { + return false; + } + + public int read() throws IOException + { + if (pos < buf.length) + return ((int) buf[pos++]) & 0xFF; + + return super.read(); + } + + public int read(byte[] b, int off, int len) throws IOException + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + int numBytes = Math.min(buf.length - pos, len); + for (int i = 0; i < numBytes; i++) + b[off++] = buf[pos++]; + + // `off' was just incremented to include `numBytes', so we can + // just pass ithere. + return numBytes + super.read(b, off, len - numBytes); + } + + public void unread(int b) throws IOException + { + if (pos <= 0) + throw new IOException(); + + buf[--pos] = (byte) b; + } + + public void unread(byte[] b) throws IOException + { + unread(b, 0, b.length); + } + + public void unread(byte[] b, int off, int len) throws IOException + { + if (pos < len) + throw new IOException(); + + // Note the order that these bytes are being added is the opposite + // of what would be done if they were added to the buffer one at a time. + // See the Java Class Libraries book p. 1390. + System.arraycopy(b, off, buf, pos - len, len); + + // Don't put this into the arraycopy above, an exception might be thrown + // and in that case we don't want to modify pos. + pos -= len; + } + + // JDK1.2 + public long skip(long n) throws IOException + { + final long origN = n; + + if (n > 0L) + { + int numread = (int) Math.min((long) (buf.length - pos), n); + pos += numread; + n -= numread; + n -= super.skip(n); + } + + return origN - n; + } +} diff --git a/libjava/java/io/PushbackReader.java b/libjava/java/io/PushbackReader.java new file mode 100644 index 00000000000..0cfd63cdb2b --- /dev/null +++ b/libjava/java/io/PushbackReader.java @@ -0,0 +1,136 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 16, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class PushbackReader extends FilterReader +{ + /* Internal buffer array for data. */ + private char[] buf; + + /* The current position in the buffer. */ + private int pos; + + public PushbackReader(Reader in) + { + this(in, 1); + } + + public PushbackReader(Reader in, int size) + { + super(in); + if (size < 0) + throw new IllegalArgumentException(); + buf = new char[size]; + pos = buf.length; + } + + public void close() throws IOException + { + synchronized (lock) + { + buf = null; + super.close(); + } + } + + public boolean markSupported() + { + return false; + } + + public int read() throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + if (pos < buf.length) + return ((int) buf[pos++]) & 0xFFFF; + + return super.read(); + } + } + + public int read(char[] b, int off, int len) throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + int numBytes = Math.min(buf.length - pos, len); + for (int i = 0; i < numBytes; i++) + b[off++] = buf[pos++]; + + return numBytes + super.read(b, off, len - numBytes); + } + } + + public boolean ready() throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + if (buf.length - pos > 0) + return true; + + return super.ready(); + } + } + + public void unread(int b) throws IOException + { + synchronized (lock) + { + if (buf == null || pos <= 0) + throw new IOException(); + + buf[--pos] = (char) b; + } + } + + public void unread(char[] b) throws IOException + { + unread(b, 0, b.length); + } + + public void unread(char[] b, int off, int len) throws IOException + { + synchronized (lock) + { + if (buf == null || pos < len) + throw new IOException(); + + // Note the order that these chars are being added is the opposite + // of what would be done if they were added to the buffer one at a time. + // See the Java Class Libraries book p. 1397. + System.arraycopy(b, off, buf, pos - len, len); + + // Don't put this into the arraycopy above, an exception might be thrown + // and in that case we don't want to modify pos. + pos -= len; + } + } +} diff --git a/libjava/java/io/RandomAccessFile.java b/libjava/java/io/RandomAccessFile.java new file mode 100644 index 00000000000..d240e0df439 --- /dev/null +++ b/libjava/java/io/RandomAccessFile.java @@ -0,0 +1,249 @@ +// RandomAccessFile.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: not finished + */ + +public class RandomAccessFile implements DataOutput, DataInput +{ + public void close () throws IOException + { + fd.close(); + } + + public final FileDescriptor getFD () throws IOException + { + if (! fd.valid()) + throw new IOException (); + return fd; + } + + public long getFilePointer () throws IOException + { + return fd.getFilePointer(); + } + + public long length () throws IOException + { + return fd.length(); + } + + public RandomAccessFile (String fileName, String mode) throws IOException + { + int fdmode; + if (mode.compareTo ("r") == 0) + fdmode = FileDescriptor.READ; + else if (mode.compareTo ("rw") == 0) + fdmode = FileDescriptor.READ | FileDescriptor.WRITE; + else + throw new IllegalArgumentException ("invalid mode: " + mode); + + SecurityManager s = System.getSecurityManager(); + if (s != null) + { + s.checkRead(fileName); + if ((fdmode & FileDescriptor.WRITE) != 0) + s.checkWrite(fileName); + } + + fd = new FileDescriptor (fileName, fdmode); + // FIXME: read-only mode. + out = new DataOutputStream (new FileOutputStream (fd)); + in = new DataInputStream (new FileInputStream (fd)); + } + + public RandomAccessFile (File file, String mode) throws IOException + { + this (file.getPath(), mode); + } + + public int read () throws IOException + { + return in.read(); + } + + public int read (byte[] buffer) throws IOException + { + return in.read(buffer); + } + + public int read (byte[] buffer, int offset, int count) throws IOException + { + return in.read(buffer, offset, count); + } + + public final boolean readBoolean () throws IOException + { + return in.readBoolean(); + } + + public final byte readByte () throws IOException + { + return in.readByte(); + } + + public final char readChar () throws IOException + { + return in.readChar(); + } + + public final double readDouble () throws IOException + { + return in.readDouble(); + } + + public final float readFloat () throws IOException + { + return in.readFloat(); + } + + public final void readFully (byte[] buffer) throws IOException + { + // FIXME. + } + + public final void readFully (byte[] buffer, int offset, int count) + throws IOException + { + // FIXME. + } + + public final int readInt () throws IOException + { + return in.readInt(); + } + + public final String readLine () throws IOException + { + // FIXME? + return in.readLine(); + } + + public final long readLong () throws IOException + { + return in.readLong(); + } + + public final short readShort () throws IOException + { + return in.readShort(); + } + + public final int readUnsignedByte () throws IOException + { + return in.readUnsignedByte(); + } + + public final int readUnsignedShort () throws IOException + { + return in.readUnsignedShort(); + } + + public final String readUTF () throws IOException + { + return in.readUTF(); + } + + public void seek (long pos) throws IOException + { + fd.seek(pos, FileDescriptor.SET); + } + + public int skipBytes (int count) throws IOException + { + return fd.seek(count, FileDescriptor.CUR); + } + + public void write (int oneByte) throws IOException + { + out.write(oneByte); + } + + public void write (byte[] buffer) throws IOException + { + out.write(buffer); + } + + public void write (byte[] buffer, int offset, int count) throws IOException + { + out.write(buffer, offset, count); + } + + public final void writeBoolean (boolean val) throws IOException + { + out.writeBoolean(val); + } + + public final void writeByte (int v) throws IOException + { + out.writeByte(v); + } + + public final void writeShort (int v) throws IOException + { + out.writeShort(v); + } + + public final void writeChar (int v) throws IOException + { + out.writeChar(v); + } + + public final void writeInt (int v) throws IOException + { + out.writeInt(v); + } + + public final void writeLong (long v) throws IOException + { + out.writeLong(v); + } + + public final void writeFloat (float v) throws IOException + { + out.writeFloat(v); + } + + public final void writeDouble (double v) throws IOException + { + out.writeDouble(v); + } + + public final void writeBytes (String s) throws IOException + { + out.writeBytes(s); + } + + public final void writeChars (String s) throws IOException + { + out.writeChars(s); + } + + public final void writeUTF (String s) throws IOException + { + out.writeUTF(s); + } + + + // The underlying file. + private FileDescriptor fd; + // The corresponding input and output streams. + private DataOutputStream out; + private DataInputStream in; +} diff --git a/libjava/java/io/Reader.java b/libjava/java/io/Reader.java new file mode 100644 index 00000000000..b54735836c2 --- /dev/null +++ b/libjava/java/io/Reader.java @@ -0,0 +1,87 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Per Bothner + * @date April 21, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public abstract class Reader +{ + protected Object lock; + + protected Reader() + { + this.lock = this; + } + + protected Reader(Object lock) + { + this.lock = lock; + } + + abstract public int read(char buf[], int offset, int count) + throws IOException; + + public int read(char buf[]) throws IOException + { + return read(buf, 0, buf.length); + } + + public int read() throws IOException + { + char[] buf = new char[1]; + int count = read(buf, 0, 1); + return count > 0 ? buf[0] : -1; + } + + abstract public void close() throws IOException; + + public boolean markSupported() + { + return false; + } + + public void mark(int readLimit) throws IOException + { + throw new IOException("mark not supported"); + } + + public void reset() throws IOException + { + throw new IOException("reset not supported"); + } + + public boolean ready() throws IOException + { + return false; + } + + public long skip(long count) throws IOException + { + if (count <= 0) + return 0; + int bsize = count > 1024 ? 1024 : (int) count; + char[] buffer = new char[bsize]; + long todo = count; + while (todo > 0) + { + int skipped = read(buffer, 0, bsize > todo ? (int) todo : bsize); + if (skipped <= 0) + break; + todo -= skipped; + } + return count - todo; + } +} diff --git a/libjava/java/io/SequenceInputStream.java b/libjava/java/io/SequenceInputStream.java new file mode 100644 index 00000000000..771351784ab --- /dev/null +++ b/libjava/java/io/SequenceInputStream.java @@ -0,0 +1,112 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +import java.util.Enumeration; + +/** + * @author Warren Levy + * @date November 3, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class SequenceInputStream extends InputStream +{ + /* The handle for the current input stream. */ + private InputStream in; + + /* Secondary input stream; not used if constructed w/ enumeration. */ + private InputStream in2; + + /* The enum handle; not used if constructed w/ 2 explicit input streams. */ + private Enumeration enum; + + public SequenceInputStream(Enumeration e) + { + // FIXME: Assumes that enum contains only InputStreams. + enum = e; + in = (InputStream) enum.nextElement(); + in2 = null; + } + + public SequenceInputStream(InputStream s1, InputStream s2) + { + in = s1; + in2 = s2; + } + + public int available() throws IOException + { + if (in == null) + return 0; + + return in.available(); + } + + public void close() throws IOException + { + while (in != null) + { + in.close(); + in = getNextStream (); + } + } + + public int read() throws IOException + { + int ch = -1; + + while (in != null && (ch = in.read()) < 0) + { + in.close(); + in = getNextStream(); + } + + return ch; + } + + public int read(byte[] b, int off, int len) throws IOException + { + int ch = -1; + + // The validity of the parameters will be checked by in.read so + // don't bother doing it here. + while (in != null && (ch = in.read(b, off, len)) < 0) + { + in.close(); + in = getNextStream(); + } + + return ch; + } + + private InputStream getNextStream() + { + InputStream nextIn = null; + + // FIXME: Assumes that enum contains only InputStreams. + if (enum != null) + { + if (enum.hasMoreElements()) + nextIn = (InputStream) enum.nextElement(); + } + else + if (in2 != null) + { + nextIn = in2; + in2 = null; + } + + return nextIn; + } +} diff --git a/libjava/java/io/Serializable.java b/libjava/java/io/Serializable.java new file mode 100644 index 00000000000..d4a31dbbad1 --- /dev/null +++ b/libjava/java/io/Serializable.java @@ -0,0 +1,21 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date August 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * Status: Believed complete + */ + +public interface Serializable +{ +} diff --git a/libjava/java/io/StreamTokenizer.java b/libjava/java/io/StreamTokenizer.java new file mode 100644 index 00000000000..d518f83b98d --- /dev/null +++ b/libjava/java/io/StreamTokenizer.java @@ -0,0 +1,433 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class StreamTokenizer +{ + /* A constant indicating that the end of the stream has been read. */ + public static final int TT_EOF = -1; + + /* A constant indicating that the end of the line has been read. */ + public static final int TT_EOL = '\n'; + + /* A constant indicating that a number token has been read. */ + public static final int TT_NUMBER = -2; + + /* A constant indicating that a word token has been read. */ + public static final int TT_WORD = -3; + + /* Contains the type of the token read resulting from a call to nextToken. */ + public int ttype; + + /* The String associated with word and string tokens. */ + public String sval; + + /* The numeric value associated with number tokens. */ + public double nval; + + /* Indicates whether end-of-line is recognized as a token. */ + private boolean eolSignificant = false; + + /* Indicates whether word tokens are automatically made lower case. */ + private boolean lowerCase = false; + + /* Indicates whether C++ style comments are recognized and skipped. */ + private boolean slashSlash = false; + + /* Indicates whether C style comments are recognized and skipped. */ + private boolean slashStar = false; + + /* Attribute tables of each byte from 0x00 to 0xFF. */ + private boolean[] whitespace; + private boolean[] alphabetic; + private boolean[] numeric; + private boolean[] quote; + private boolean[] comment; + + /* The Reader associated with this class. */ + private PushbackReader in; + + /* Indicates if a token has been pushed back. */ + private boolean pushedBack = false; + + /* Contains the current line number of the reader. */ + private int lineNumber = 1; + + // Deprecated in JDK 1.1. + public StreamTokenizer(InputStream is) + { + this(new InputStreamReader(is)); + } + + public StreamTokenizer(Reader r) + { + in = new PushbackReader(r); + + whitespace = new boolean[256]; + alphabetic = new boolean[256]; + numeric = new boolean[256]; + quote = new boolean[256]; + comment = new boolean[256]; + for (int i = 0; i < 256; i++) + resetChar(i); + + whitespaceChars(0x00, 0x20); + wordChars('A', 'Z'); + wordChars('a', 'z'); + wordChars(0xA0, 0xFF); + commentChar('/'); + quoteChar('\''); + quoteChar('"'); + parseNumbers(); + } + + public void commentChar(int ch) + { + if (ch >= 0 && ch <= 255) + comment[ch] = true; + } + + public void eolIsSignificant(boolean flag) + { + eolSignificant = flag; + } + + public int lineno() + { + return lineNumber; + } + + public void lowerCaseMode(boolean flag) + { + lowerCase = flag; + } + + private boolean isWhitespace(int ch) + { + if (ch >= 0 && ch <= 255) + return whitespace[ch]; + + return false; + } + + private boolean isAlphabetic(int ch) + { + if (ch >= 0 && ch <= 255) + return alphabetic[ch]; + else if (ch > 255) + return true; + + return false; + } + + private boolean isNumeric(int ch) + { + if (ch >= 0 && ch <= 255) + return numeric[ch]; + + return false; + } + + private boolean isQuote(int ch) + { + if (ch >= 0 && ch <= 255) + return quote[ch]; + + return false; + } + + private boolean isComment(int ch) + { + if (ch >= 0 && ch <= 255) + return comment[ch]; + + return false; + } + + public int nextToken() throws IOException + { + if (pushedBack) + { + pushedBack = false; + return ttype; + } + + sval = null; + int ch; + + // Skip whitespace. Deal with EOL along the way. + while (isWhitespace(ch = in.read())) + if (ch == '\n' || ch == '\r') + { + lineNumber++; + + // Throw away \n if in combination with \r. + if (ch == '\r' && (ch = in.read()) != '\n') + in.unread(ch); + if (eolSignificant) + return (ttype = TT_EOL); + } + + if (ch == TT_EOF) + ttype = TT_EOF; + else if (isNumeric(ch)) + { + if (ch == '-') + { + // Read ahead to see if this is an ordinary '-' rather than numeric. + ch = in.read(); + in.unread(ch); + if (isNumeric(ch) && ch != '-') + ch = '-'; + else + return (ttype = '-'); + } + + StringBuffer tokbuf = new StringBuffer(); + tokbuf.append((char) ch); + + int decCount = 0; + while (isNumeric(ch = in.read()) && ch != '-') + if (ch == '.' && decCount++ > 0) + break; + else + tokbuf.append((char) ch); + + in.unread(ch); + ttype = TT_NUMBER; + nval = Double.valueOf(tokbuf.toString()).doubleValue(); + } + else if (isAlphabetic(ch)) + { + StringBuffer tokbuf = new StringBuffer(); + tokbuf.append((char) ch); + while (isAlphabetic(ch = in.read()) || isNumeric(ch)) + tokbuf.append((char) ch); + in.unread(ch); + ttype = TT_WORD; + sval = tokbuf.toString(); + if (lowerCase) + sval.toLowerCase(); + } + else if (isComment(ch)) + { + while ((ch = in.read()) != '\n' && ch != '\r' && ch != TT_EOF) + ; + in.unread(ch); + return nextToken(); // Recursive, but not too deep in normal cases. + } + else if (isQuote(ch)) + { + ttype = ch; + StringBuffer tokbuf = new StringBuffer(); + while ((ch = in.read()) != ttype && ch != '\n' && ch != '\r' && + ch != TT_EOF) + { + if (ch == '\\') + switch (ch = in.read()) + { + case 'a': ch = 0x7; + break; + case 'b': ch = '\b'; + break; + case 'f': ch = 0xC; + break; + case 'n': ch = '\n'; + break; + case 'r': ch = '\r'; + break; + case 't': ch = '\t'; + break; + case 'v': ch = 0xB; + break; + case '\"': + case '\'': + case '\\': + break; + default: + int ch1, nextch; + if ((nextch = ch1 = ch) >= '0' && ch <= '7') + { + ch -= '0'; + if ((nextch = in.read()) >= '0' && nextch <= '7') + { + ch = ch * 8 + nextch - '0'; + if ((nextch = in.read()) >= '0' && nextch <= '7' && + ch1 >= '0' && ch1 <= '3') + { + ch = ch * 8 + nextch - '0'; + nextch = in.read(); + } + } + } + + in.unread(nextch); + } + + tokbuf.append((char) ch); + } + + // Throw away matching quote char. + if (ch != ttype) + in.unread(ch); + + sval = tokbuf.toString(); + } + else + { + if (ch == '/') + if ((ch = in.read()) == '/' && slashSlash) + { + while ((ch = in.read()) != '\n' && ch != '\r' && ch != TT_EOF) + ; + in.unread(ch); + return nextToken(); // Recursive, but not too deep in normal cases + } + else if (ch == '*' && slashStar) + { + while (true) + { + ch = in.read(); + if (ch == '*') + if ((ch = in.read()) == '/') + break; + else + in.unread(ch); + else if (ch == '\n' || ch == '\r') + { + lineNumber++; + if (ch == '\r' && (ch = in.read()) != '\n') + in.unread(ch); + } + else if (ch == TT_EOF) + { + in.unread(ch); + break; + } + } + return nextToken(); // Recursive, but not too deep in normal cases + } + else + { + in.unread(ch); + ch = '/'; + } + + ttype = ch; + } + + return ttype; + } + + private void resetChar(int ch) + { + whitespace[ch] = alphabetic[ch] = numeric[ch] = quote[ch] = comment[ch] = + false; + } + + public void ordinaryChar(int ch) + { + if (ch >= 0 && ch <= 255) + resetChar(ch); + } + + public void ordinaryChars(int low, int hi) + { + if (low < 0) + low = 0; + if (hi > 255) + hi = 255; + for (int i = low; i <= hi; i++) + resetChar(i); + } + + public void parseNumbers() + { + for (int i = 0; i <= 9; i++) + numeric['0' + i] = true; + + numeric['.'] = true; + numeric['-'] = true; + } + + public void pushBack() + { + // pushBack may cause the lineno method to return an incorrect value + // if lineno is called before the next call to nextToken. + pushedBack = true; + } + + public void quoteChar(int ch) + { + if (ch >= 0 && ch <= 255) + quote[ch] = true; + } + + public void resetSyntax() + { + ordinaryChars(0x00, 0xFF); + } + + public void slashSlashComments(boolean flag) + { + slashSlash = flag; + } + + public void slashStarComments(boolean flag) + { + slashStar = flag; + } + + public String toString() + { + String tempstr; + if (ttype == TT_EOF) + tempstr = "EOF"; + else if (ttype == TT_EOL) + tempstr = "EOL"; + else if (ttype == TT_WORD) + tempstr = sval; + else if (ttype == TT_NUMBER) + tempstr = "n=" + Double.toString(nval); + else // must be an ordinary char. + tempstr = "\'" + (new Character((char) ttype)).toString() + "\'"; + + return "Token[" + tempstr + "], line " + Integer.toString(lineno()); + } + + public void whitespaceChars(int low, int hi) + { + if (low < 0) + low = 0; + if (hi > 255) + hi = 255; + for (int i = low; i <= hi; i++) + whitespace[i] = true; + } + + public void wordChars(int low, int hi) + { + if (low < 0) + low = 0; + if (hi > 255) + hi = 255; + for (int i = low; i <= hi; i++) + alphabetic[i] = true; + } +} diff --git a/libjava/java/io/StringBufferInputStream.java b/libjava/java/io/StringBufferInputStream.java new file mode 100644 index 00000000000..19e89db592c --- /dev/null +++ b/libjava/java/io/StringBufferInputStream.java @@ -0,0 +1,83 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date November 11, 1998. + * @deprecated + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. Deprecated in JDK 1.1. + */ + +public class StringBufferInputStream extends InputStream +{ + /* The String which is the input to this stream. */ + protected String buffer; + + /* Position of the next byte in buffer to be read. */ + protected int pos = 0; + + /* The length of the String buffer. */ + protected int count; + + public StringBufferInputStream(String s) + { + buffer = s; + count = s.length(); + } + + public int available() + { + return count - pos; + } + + public int read() + { + if (pos >= count) + return -1; // EOF + + return ((int) buffer.charAt(pos++)) & 0xFF; + } + + public int read(byte[] b, int off, int len) + { + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + if (pos >= count) + return -1; // EOF + + int numRead = Math.min(len, count - pos); + if (numRead < 0) + return 0; + + buffer.getBytes(pos, pos + numRead, b, off); + pos += numRead; + return numRead; + } + + public void reset() + { + pos = 0; + } + + public long skip(long n) + { + if (n < 0) + return 0L; + + long actualSkip = Math.min(n, count - pos); + pos += actualSkip; + return actualSkip; + } +} diff --git a/libjava/java/io/StringReader.java b/libjava/java/io/StringReader.java new file mode 100644 index 00000000000..08e8d0c4f15 --- /dev/null +++ b/libjava/java/io/StringReader.java @@ -0,0 +1,139 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Warren Levy + * @date October 19, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +public class StringReader extends Reader +{ + /* A String provided by the creator of the stream. */ + private String buf; + + /* Position of the next char in buf to be read. */ + private int pos; + + /* The currently marked position in the stream. */ + private int markedPos; + + /* The index in buf one greater than the last valid character. */ + private int count; + + public StringReader(String buffer) + { + super(); + buf = buffer; + + count = buffer.length(); + markedPos = pos = 0; + } + + public void close() + { + synchronized (lock) + { + buf = null; + } + } + + public void mark(int readAheadLimit) throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + // readAheadLimit is ignored per Java Class Lib. book, p. 1692. + markedPos = pos; + } + } + + public boolean markSupported() + { + return true; + } + + public int read() throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + if (pos < count) + return ((int) buf.charAt(pos++)) & 0xFFFF; + return -1; + } + } + + public int read(char[] b, int off, int len) throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + /* Don't need to check pos value, arraycopy will check it. */ + if (off < 0 || len < 0 || off + len > b.length) + throw new ArrayIndexOutOfBoundsException(); + + if (pos >= count) + return -1; + + int lastChar = Math.min(count, pos + len); + buf.getChars(pos, lastChar, b, off); + int numChars = lastChar - pos; + pos = lastChar; + return numChars; + } + } + + public boolean ready() // TODO12: throws IOException + { + // TODO12: The JCL specifically says this returns true even if the + // reader has been closed, whereas the online 1.2 doc specifically + // says to throw an IOException if closed. + return true; + } + + public void reset() throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + pos = markedPos; + } + } + + public long skip(long n) throws IOException + { + synchronized (lock) + { + if (buf == null) + throw new IOException(); + + // Even though the var numChars is a long, in reality it can never + // be larger than an int since the result of subtracting 2 positive + // ints will always fit in an int. Since we have to return a long + // anyway, numChars might as well just be a long. + long numChars = Math.min((long) (count - pos), n < 0 ? 0L : n); + pos += numChars; + return numChars; + } + } +} diff --git a/libjava/java/io/StringWriter.java b/libjava/java/io/StringWriter.java new file mode 100644 index 00000000000..90ad9a9b688 --- /dev/null +++ b/libjava/java/io/StringWriter.java @@ -0,0 +1,80 @@ +// StringWriter.java - StringBuffer output stream + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class StringWriter extends Writer +{ + public void close () + { + // JCL says this does nothing. This seems to violate the Writer + // contract, in that other methods should still throw and + // IOException after a close. Still, we just follow JCL. + } + + public void flush () + { + } + + public StringBuffer getBuffer () + { + return buffer; + } + + public StringWriter () + { + this (16); + } + + protected StringWriter (int size) + { + super (); + buffer = new StringBuffer (size); + lock = buffer; + } + + public String toString () + { + return buffer.toString(); + } + + public void write (int oneChar) + { + buffer.append((char) oneChar); + } + + public void write (char[] chars, int offset, int len) + { + buffer.append(chars, offset, len); + } + + public void write (String str) + { + buffer.append(str); + } + + public void write (String str, int offset, int len) + { + buffer.append(str.substring(offset, offset + len)); + } + + // The string buffer. + private StringBuffer buffer; +} diff --git a/libjava/java/io/SyncFailedException.java b/libjava/java/io/SyncFailedException.java new file mode 100644 index 00000000000..b920198edf6 --- /dev/null +++ b/libjava/java/io/SyncFailedException.java @@ -0,0 +1,34 @@ +// SyncFailedException.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class SyncFailedException extends IOException +{ + public SyncFailedException () + { + super (); + } + + public SyncFailedException (String s) + { + super (s); + } +} diff --git a/libjava/java/io/UTFDataFormatException.java b/libjava/java/io/UTFDataFormatException.java new file mode 100644 index 00000000000..aea35401772 --- /dev/null +++ b/libjava/java/io/UTFDataFormatException.java @@ -0,0 +1,34 @@ +// UTFDataFormatException.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Tom Tromey + * @date September 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Complete to 1.1. + */ + +public class UTFDataFormatException extends IOException +{ + public UTFDataFormatException () + { + super (); + } + + public UTFDataFormatException (String s) + { + super (s); + } +} diff --git a/libjava/java/io/UnsupportedEncodingException.java b/libjava/java/io/UnsupportedEncodingException.java new file mode 100644 index 00000000000..f3c26f9b316 --- /dev/null +++ b/libjava/java/io/UnsupportedEncodingException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Per Bothner + * @date April 17, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class UnsupportedEncodingException extends IOException +{ + public UnsupportedEncodingException () + { + super(); + } + + public UnsupportedEncodingException (String msg) + { + super(msg); + } +} diff --git a/libjava/java/io/Writer.java b/libjava/java/io/Writer.java new file mode 100644 index 00000000000..48cedb63114 --- /dev/null +++ b/libjava/java/io/Writer.java @@ -0,0 +1,67 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.io; + +/** + * @author Per Bothner + * @date April 17, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + * However, write(String, int, int) should be made a native method. + */ + +public abstract class Writer +{ + protected Object lock; + + protected Writer () + { + lock = this; + } + + protected Writer (Object lock) + { + this.lock = lock; + } + + abstract public void close() throws IOException; + + abstract public void flush() throws IOException; + + abstract public void write(char[] buf, int offset, int count) + throws IOException; + + public void write(char[] buf) throws IOException + { + write(buf, 0, buf.length); + } + + public void write(int ch) throws IOException + { + char[] buf = new char[1]; + buf[0] = (char) ch; + write(buf, 0, 1); + } + + // FIXME - re-write using native code to not require copied buffer. + public void write (String str, int offset, int count) throws IOException + { + char[] buf = new char[count]; + str.getChars(offset, offset + count, buf, 0); + write(buf, 0, count); + } + + public void write (String str) throws IOException + { + write(str, 0, str.length()); + } + +} diff --git a/libjava/java/io/natFile.cc b/libjava/java/io/natFile.cc new file mode 100644 index 00000000000..40f227719e5 --- /dev/null +++ b/libjava/java/io/natFile.cc @@ -0,0 +1,273 @@ +// natFile.cc - Native part of File class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include +#include +#include +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#ifdef HAVE_DIRENT_H +#define _POSIX_PTHREAD_SEMANTICS +#ifndef _REENTRANT +# define _REENTRANT +#endif +#include +#endif +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +jboolean +java::io::File::access (jstring canon, jint query) +{ + if (! canon) + return false; + char buf[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (canon, 0, canon->length(), buf); + // FIXME? + buf[total] = '\0'; + JvAssert (query == READ || query == WRITE || query == EXISTS); +#ifdef HAVE_ACCESS + int mode; + if (query == READ) + mode = R_OK; + else if (query == WRITE) + mode = W_OK; + else + mode = F_OK; + return ::access (buf, mode) == 0; +#else + return false; +#endif +} + +jboolean +java::io::File::stat (jstring canon, jint query) +{ + if (! canon) + return false; + char buf[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (canon, 0, canon->length(), buf); + // FIXME? + buf[total] = '\0'; + +#ifdef HAVE_STAT + struct stat sb; + if (::stat (buf, &sb)) + return false; + + JvAssert (query == DIRECTORY || query == ISFILE); + jboolean r = S_ISDIR (sb.st_mode); + return query == DIRECTORY ? r : ! r; +#else + return false; +#endif +} + +jlong +java::io::File::attr (jstring canon, jint query) +{ + if (! canon) + return false; + + char buf[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (canon, 0, canon->length(), buf); + // FIXME? + buf[total] = '\0'; + +#ifdef HAVE_STAT + struct stat sb; + // FIXME: not sure about return value here. + if (::stat (buf, &sb)) + return 0; + + JvAssert (query == MODIFIED || query == LENGTH); + // FIXME: time computation is very POSIX-specific -- POSIX and Java + // have the same Epoch. + return query == MODIFIED ? sb.st_mtime * 1000 : sb.st_size; +#else + // There's no good choice here. + return 23; +#endif +} + +jstring +java::io::File::getCanonicalPath (void) +{ + char buf[MAXPATHLEN], buf2[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf); + // FIXME? + buf[total] = '\0'; + +#ifdef HAVE_REALPATH + if (realpath (buf, buf2) == NULL) + _Jv_Throw (new IOException (JvNewStringLatin1 (strerror (errno)))); + + // FIXME: what encoding to assume for file names? This affects many + // calls. + return JvNewStringUTF (buf2); +#else + return JvNewStringUTF (buf); +#endif +} + +jboolean +java::io::File::isAbsolute (void) +{ + // FIXME: cpp define name. + // FIXME: cygwin. +#ifdef WIN32 + if (path->charAt(0) == '/' || path->charAt(0) == '\\') + return true; + if (path->length() < 3) + return false; + // Hard-code A-Za-z because Windows (I think) can't use non-ASCII + // letters as drive names. + if ((path->charAt(0) < 'a' || path->charAt(0) > 'z') + && (path->charAt(0) < 'A' || path->charAt(0) > 'Z')) + return false; + return (path->charAt(1) == ':' + && (path->charAt(2) == '/' || path->charAt(2) == '\\')); +#else + return path->charAt(0) == '/'; +#endif +} + +#ifdef HAVE_DIRENT_H +#if defined(__JV_POSIX_THREADS__) && defined(HAVE_READDIR_R) + +static struct dirent * +get_entry (DIR *dir, struct dirent *e) +{ + struct dirent *r; + if (readdir_r (dir, e, &r) || r == NULL) + return NULL; + return e; +} + +#else /* defined(__JV_POSIX_THREADS__) && defined(HAVE_READDIR_R) */ + +static struct dirent * +get_entry (DIR *dir, struct dirent *) +{ + return readdir (dir); +} + +#endif /* defined(__JV_POSIX_THREADS__) && defined(HAVE_READDIR_R) */ +#endif /* HAVE_DIRENT_H */ + +jstringArray +java::io::File::performList (jstring canon, FilenameFilter *filter) +{ + if (! canon) + return NULL; + +#ifdef HAVE_DIRENT_H + char buf[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (canon, 0, canon->length(), buf); + // FIXME? + buf[total] = '\0'; + + DIR *dir = opendir (buf); + if (! dir) + return NULL; + + java::util::Vector *vec = new java::util::Vector (); + struct dirent *d, d2; + while ((d = get_entry (dir, &d2)) != NULL) + { + if (! strcmp (d->d_name, ".") || ! strcmp (d->d_name, "..")) + continue; + + jstring name = JvNewStringUTF (d->d_name); + if (filter && ! filter->accept(this, name)) + continue; + + vec->addElement(name); + } + + closedir (dir); + + jobjectArray ret = JvNewObjectArray (vec->size(), canon->getClass(), + NULL); + vec->copyInto(ret); + return reinterpret_cast (ret); +#else /* HAVE_DIRENT_H */ + return NULL; +#endif /* HAVE_DIRENT_H */ +} + +jboolean +java::io::File::performMkdir (void) +{ + char buf[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf); + // FIXME? + buf[total] = '\0'; + +#ifdef HAVE_MKDIR + // FIXME: mode. + return ::mkdir (buf, 0755) == 0; +#else + return false; +#endif +} + +jboolean +java::io::File::performRenameTo (File *dest) +{ + char buf[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf); + // FIXME? + buf[total] = '\0'; + char buf2[MAXPATHLEN]; + total = JvGetStringUTFRegion (dest->path, 0, dest->path->length(), buf2); + // FIXME? + buf2[total] = '\0'; + +#ifdef HAVE_RENAME + return ::rename (buf, buf2) == 0; +#else + return false; +#endif +} + +jboolean +java::io::File::performDelete (jstring canon) +{ + char buf[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (canon, 0, canon->length(), buf); + // FIXME? + buf[total] = '\0'; + +#ifdef HAVE_UNLINK +#ifdef HAVE_RMDIR + if (! ::rmdir (buf)) + return true; +#endif // HAVE_RMDIR + if (errno == ENOTDIR) + return ::unlink (buf) == 0; +#endif // HAVE_UNLINK + return false; +} diff --git a/libjava/java/io/natFileDescriptorEcos.cc b/libjava/java/io/natFileDescriptorEcos.cc new file mode 100644 index 00000000000..f2c3fb0db79 --- /dev/null +++ b/libjava/java/io/natFileDescriptorEcos.cc @@ -0,0 +1,132 @@ +// natFileDescriptor.cc - Native part of FileDescriptor class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern "C" void diag_write_char (char c); + +static void +diag_write (char *data, int len) +{ + while (len > 0) + { + diag_write_char (*data++); + len--; + } +} + +#define NO_FSYNC_MESSAGE "sync unsupported" + +jboolean +java::io::FileDescriptor::valid (void) +{ + return true; +} + +void +java::io::FileDescriptor::sync (void) +{ + // Some files don't support fsync. We don't bother reporting these + // as errors. +#ifdef HAVE_FSYNC +#else + JvThrow (new SyncFailedException (JvNewStringLatin1 (NO_FSYNC_MESSAGE))); +#endif +} + +jint +java::io::FileDescriptor::open (jstring path, jint jflags) +{ + return fd; +} + +void +java::io::FileDescriptor::write (jint b) +{ + char d = (char) b; + ::diag_write (&d, 1); +} + +void +java::io::FileDescriptor::write (jbyteArray b, jint offset, jint len) +{ + if (! b) + JvThrow (new java::lang::NullPointerException); + if (offset < 0 || len < 0 || offset + len > JvGetArrayLength (b)) + JvThrow (new java::lang::ArrayIndexOutOfBoundsException); + char *bytes = (char *)elements (b) + offset; + ::diag_write (bytes, len); +} + +void +java::io::FileDescriptor::close (void) +{ +} + +jint +java::io::FileDescriptor::seek (jlong pos, jint whence) +{ + JvAssert (whence == SET || whence == CUR); + + jlong len = length (); + jlong here = getFilePointer (); + + if ((whence == SET && pos > len) || (whence == CUR && here + pos > len)) + JvThrow (new EOFException); + + return 0; +} + +jlong +java::io::FileDescriptor::length (void) +{ + return 0; +} + +jlong +java::io::FileDescriptor::getFilePointer (void) +{ + return 0; +} + +jint +java::io::FileDescriptor::read (void) +{ + return 0; +} + +jint +java::io::FileDescriptor::read (jbyteArray buffer, jint offset, jint count) +{ + return 0; +} + +jint +java::io::FileDescriptor::available (void) +{ + return 0; +} diff --git a/libjava/java/io/natFileDescriptorPosix.cc b/libjava/java/io/natFileDescriptorPosix.cc new file mode 100644 index 00000000000..3efd8e4791b --- /dev/null +++ b/libjava/java/io/natFileDescriptorPosix.cc @@ -0,0 +1,264 @@ +// natFileDescriptor.cc - Native part of FileDescriptor class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#include +#include +#ifdef HAVE_SYS_TIME_H +#include +#endif +#include +#include +#include +#include + +#ifdef HAVE_SYS_IOCTL_H +#define BSD_COMP /* Get FIONREAD on Solaris2. */ +#include +#endif + +// Pick up FIONREAD on Solaris 2.5. +#ifdef HAVE_SYS_FILIO_H +#include +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define NO_FSYNC_MESSAGE "sync unsupported" + +jboolean +java::io::FileDescriptor::valid (void) +{ + struct stat sb; + return ::fstat (fd, &sb) == 0; +} + +void +java::io::FileDescriptor::sync (void) +{ + // Some files don't support fsync. We don't bother reporting these + // as errors. +#ifdef HAVE_FSYNC + if (::fsync (fd) && errno != EROFS && errno != EINVAL) + JvThrow (new SyncFailedException (JvNewStringLatin1 (strerror (errno)))); +#else + JvThrow (new SyncFailedException (JvNewStringLatin1 (NO_FSYNC_MESSAGE))); +#endif +} + +jint +java::io::FileDescriptor::open (jstring path, jint jflags) +{ + // FIXME: eww. + char buf[MAXPATHLEN]; + jsize total = JvGetStringUTFRegion (path, 0, path->length(), buf); + // FIXME? + buf[total] = '\0'; + int flags = 0; +#ifdef O_BINARY + flags |= O_BINARY; +#endif + + JvAssert ((jflags & READ) || (jflags & WRITE)); + if ((jflags & READ) && (jflags & WRITE)) + flags |= O_RDWR; + else if ((jflags & READ)) + flags |= O_RDONLY; + else + { + flags |= O_WRONLY | O_CREAT; + if ((jflags & APPEND)) + flags |= O_APPEND; + else + flags |= O_TRUNC; + } + + // FIXME: mode? + int fd = ::open (buf, flags, 0755); + if (fd == -1) + { + char msg[MAXPATHLEN + 200]; + sprintf (msg, "%s: %s", buf, strerror (errno)); + JvThrow (new FileNotFoundException (JvNewStringLatin1 (msg))); + } + return fd; +} + +void +java::io::FileDescriptor::write (jint b) +{ + jbyte d = (jbyte) b; + int r = ::write (fd, &d, 1); + if (java::lang::Thread::interrupted()) + { + InterruptedIOException *iioe + = new InterruptedIOException (JvNewStringLatin1 ("write interrupted")); + iioe->bytesTransferred = r == -1 ? 0 : r; + JvThrow (iioe); + } + else if (r == -1) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + // FIXME: loop if r != 1. +} + +void +java::io::FileDescriptor::write (jbyteArray b, jint offset, jint len) +{ + if (! b) + JvThrow (new java::lang::NullPointerException); + if (offset < 0 || len < 0 || offset + len > JvGetArrayLength (b)) + JvThrow (new java::lang::ArrayIndexOutOfBoundsException); + jbyte *bytes = elements (b) + offset; + int r = ::write (fd, bytes, len); + if (java::lang::Thread::interrupted()) + { + InterruptedIOException *iioe + = new InterruptedIOException (JvNewStringLatin1 ("write interrupted")); + iioe->bytesTransferred = r == -1 ? 0 : r; + JvThrow (iioe); + } + else if (r == -1) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + // FIXME: loop if r != len. +} + +void +java::io::FileDescriptor::close (void) +{ + jint save = fd; + fd = -1; + if (::close (save)) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); +} + +jint +java::io::FileDescriptor::seek (jlong pos, jint whence) +{ + JvAssert (whence == SET || whence == CUR); + + jlong len = length (); + jlong here = getFilePointer (); + + if ((whence == SET && pos > len) || (whence == CUR && here + pos > len)) + JvThrow (new EOFException); + + off_t r = ::lseek (fd, (off_t) pos, whence == SET ? SEEK_SET : SEEK_CUR); + if (r == -1) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + return r; +} + +jlong +java::io::FileDescriptor::length (void) +{ + struct stat sb; + if (::fstat (fd, &sb)) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + return sb.st_size; +} + +jlong +java::io::FileDescriptor::getFilePointer (void) +{ + off_t r = ::lseek (fd, 0, SEEK_CUR); + if (r == -1) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + return r; +} + +jint +java::io::FileDescriptor::read (void) +{ + jbyte b; + int r = ::read (fd, &b, 1); + if (r == 0) + return -1; + if (java::lang::Thread::interrupted()) + { + InterruptedIOException *iioe + = new InterruptedIOException (JvNewStringLatin1 ("read interrupted")); + iioe->bytesTransferred = r == -1 ? 0 : r; + JvThrow (iioe); + } + else if (r == -1) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + return b & 0xFF; +} + +jint +java::io::FileDescriptor::read (jbyteArray buffer, jint offset, jint count) +{ + if (! buffer) + JvThrow (new java::lang::NullPointerException); + jsize bsize = JvGetArrayLength (buffer); + if (offset < 0 || count < 0 || offset + count > bsize) + JvThrow (new java::lang::ArrayIndexOutOfBoundsException); + jbyte *bytes = elements (buffer) + offset; + int r = ::read (fd, bytes, count); + if (r == 0) + return -1; + if (java::lang::Thread::interrupted()) + { + InterruptedIOException *iioe + = new InterruptedIOException (JvNewStringLatin1 ("read interrupted")); + iioe->bytesTransferred = r == -1 ? 0 : r; + JvThrow (iioe); + } + else if (r == -1) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + return r; +} + +jint +java::io::FileDescriptor::available (void) +{ +#if defined (FIONREAD) + long num; + int r = ::ioctl (fd, FIONREAD, &num); + if (r == -1) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + return (jint) num; +#elif defined (HAVE_SELECT) + int r = -1; + if (fd < 0) + errno = EBADF; + else + { + fd_set rd; + FD_ZERO (&rd); + FD_SET (fd, &rd); + struct timeval tv; + tv.tv_sec = 0; + tv.tv_usec = 0; + r = ::select (fd + 1, &rd, NULL, NULL, &tv); + } + if (r == -1) + JvThrow (new IOException (JvNewStringLatin1 (strerror (errno)))); + return r == 0 ? 0 : 1; +#else + JvThrow (new IOException (JvNewStringLatin1 ("unimplemented"))); +#endif +} diff --git a/libjava/java/lang/AbstractMethodError.java b/libjava/java/lang/AbstractMethodError.java new file mode 100644 index 00000000000..b1751e2e0f1 --- /dev/null +++ b/libjava/java/lang/AbstractMethodError.java @@ -0,0 +1,34 @@ +// AbstractMethodError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class AbstractMethodError extends IncompatibleClassChangeError +{ + public AbstractMethodError () + { + super (); + } + + public AbstractMethodError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/ArithmeticException.java b/libjava/java/lang/ArithmeticException.java new file mode 100644 index 00000000000..def8c82be77 --- /dev/null +++ b/libjava/java/lang/ArithmeticException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ArithmeticException extends RuntimeException +{ + public ArithmeticException() + { + super(); + } + + public ArithmeticException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/ArrayIndexOutOfBoundsException.java b/libjava/java/lang/ArrayIndexOutOfBoundsException.java new file mode 100644 index 00000000000..e66b6d7189b --- /dev/null +++ b/libjava/java/lang/ArrayIndexOutOfBoundsException.java @@ -0,0 +1,37 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException +{ + public ArrayIndexOutOfBoundsException() + { + super(); + } + + public ArrayIndexOutOfBoundsException(int index) + { + this("Array index out of range: " + index); + } + + public ArrayIndexOutOfBoundsException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/ArrayStoreException.java b/libjava/java/lang/ArrayStoreException.java new file mode 100644 index 00000000000..7b9ede6ff25 --- /dev/null +++ b/libjava/java/lang/ArrayStoreException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ArrayStoreException extends RuntimeException +{ + public ArrayStoreException() + { + super(); + } + + public ArrayStoreException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/Boolean.java b/libjava/java/lang/Boolean.java new file mode 100644 index 00000000000..78ab77ff81a --- /dev/null +++ b/libjava/java/lang/Boolean.java @@ -0,0 +1,95 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +import java.io.Serializable; + +/** + * @author Warren Levy + * @date September 3, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public final class Boolean extends Object implements Serializable +{ + public static final Boolean FALSE = new Boolean(false); + public static final Boolean TRUE = new Boolean(true); + + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public static final Class TYPE = boolean.class; + + /* The boolean value of the instance. */ + private boolean value; + + public Boolean(boolean boolVal) + { + value = boolVal; + } + + public Boolean(String strVal) + { + value = strVal.equalsIgnoreCase("true"); + } + + public boolean booleanValue() + { + return value; + } + + public boolean equals(Object obj) + { + /* Don't need to compare obj to null as instanceof will do this. */ + if (obj instanceof Boolean) + return value == ((Boolean) obj).value; + return false; + } + + public static boolean getBoolean(String property) + { + /* TBD: If a security manager exists and it doesn't permit accessing + * the property, it will throw an exception. Should we catch it? + */ + try + { + String val = System.getProperty(property); + return val == null ? false : val.equalsIgnoreCase("true"); + } + catch (SecurityException e) + { + return false; + } + } + + public int hashCode() + { + /* These values are from the Java Lang. Spec. (Sec 20.4.7). + * TBD: They could be made private static final fields but they're only + * used here (and shouldn't be used anywhere else), though it might be + * useful to grep on something like JAVA_HASH_* values for us as + * developers. + */ + return value ? 1231 : 1237; + } + + public String toString() + { + return value ? "true" : "false"; + } + + public static Boolean valueOf(String str) + { + /* This returns a Boolean (big B), not a boolean (little b). */ + return str.equalsIgnoreCase("true") ? TRUE : FALSE; + } +} diff --git a/libjava/java/lang/Byte.java b/libjava/java/lang/Byte.java new file mode 100644 index 00000000000..f3ec4020671 --- /dev/null +++ b/libjava/java/lang/Byte.java @@ -0,0 +1,144 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Per Bothner + * @date April 17, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + * Includes JDK 1.2 methods. + */ + +public final class Byte extends Number implements Comparable +{ + byte value; + + public final static byte MIN_VALUE = -128; + public final static byte MAX_VALUE = 127; + + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public static final Class TYPE = byte.class; + + public Byte(byte value) + { + this.value = value; + } + + public Byte(String str) + throws NumberFormatException + { + this.value = parseByte(str, 10); + } + + public byte byteValue() + { + return value; + } + + public short shortValue() + { + return value; + } + + public int intValue() + { + return value; + } + + public long longValue () + { + return value; + } + + public float floatValue () + { + return (float) value; + } + + public double doubleValue () + { + return (double) value; + } + + public static Byte decode(String str) + throws NumberFormatException + { + int i = (Integer.decode(str)).intValue(); + if (i < MIN_VALUE || i > MAX_VALUE) + throw new NumberFormatException(); + return new Byte((byte) i); + } + + public static byte parseByte(String str, int radix) + throws NumberFormatException + { + int i = Integer.parseInt(str, radix); + if (i < MIN_VALUE || i > MAX_VALUE) + throw new NumberFormatException(); + return (byte) i; + } + + public static byte parseByte(String str) + throws NumberFormatException + { + return parseByte(str, 10); + } + + public static Byte valueOf(String str, int radix) + throws NumberFormatException + { + return new Byte(parseByte(str, radix)); + } + + public static Byte valueOf(String str) + throws NumberFormatException + { + return valueOf(str, 10); + } + + // Added in JDK 1.2 + public int compareTo(Byte anotherByte) + { + return this.value - anotherByte.value; + } + + // Added in JDK 1.2 + public int compareTo(Object o) throws ClassCastException + { + if (o instanceof Byte) + return this.value - ((Byte) o).value; + else + throw new ClassCastException(); + } + + public boolean equals(Object obj) + { + return obj != null && (obj instanceof Byte) && ((Byte)obj).value == value; + } + + // Verified that hashCode is returns plain value (see Boolean_1 test). + public int hashCode() + { + return value; + } + + public String toString() + { + return Integer.toString((int) value); + } + + public static String toString(byte value) + { + return Integer.toString((int) value); + } +} diff --git a/libjava/java/lang/Character.java b/libjava/java/lang/Character.java new file mode 100644 index 00000000000..c7dd052e0c0 --- /dev/null +++ b/libjava/java/lang/Character.java @@ -0,0 +1,286 @@ +// Character.java - Character class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +import java.io.Serializable; + +/** + * @author Tom Tromey + * @date September 10, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1, + * online API docs for JDK 1.2 beta from http://www.javasoft.com, + * and The Unicode Standard Version 2.0. + * Status: Believed complete and correct for JDK 1.1; 1.2 methods + * unimplemented. + */ + +public final class Character implements Serializable, Comparable +{ + public static final char MIN_VALUE = '\u0000'; + public static final char MAX_VALUE = '\uffff'; + + public static final int MIN_RADIX = 2; + public static final int MAX_RADIX = 36; + + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public static final Class TYPE = char.class; + + // Space. + public static final byte SPACE_SEPARATOR = 12; + public static final byte LINE_SEPARATOR = 13; + public static final byte PARAGRAPH_SEPARATOR = 14; + + // Letters. + public static final byte UPPERCASE_LETTER = 1; + public static final byte LOWERCASE_LETTER = 2; + public static final byte TITLECASE_LETTER = 3; + public static final byte MODIFIER_LETTER = 4; + public static final byte OTHER_LETTER = 5; + + // Numbers. + public static final byte DECIMAL_DIGIT_NUMBER = 9; + public static final byte LETTER_NUMBER = 10; + public static final byte OTHER_NUMBER = 11; + + // Marks. + public static final byte NON_SPACING_MARK = 6; + public static final byte ENCLOSING_MARK = 7; + public static final byte COMBINING_SPACING_MARK = 8; + + // Punctuation. + public static final byte DASH_PUNCTUATION = 20; + public static final byte START_PUNCTUATION = 21; + public static final byte END_PUNCTUATION = 22; + public static final byte CONNECTOR_PUNCTUATION = 23; + public static final byte OTHER_PUNCTUATION = 24; + + // Symbols. + public static final byte MATH_SYMBOL = 25; + public static final byte CURRENCY_SYMBOL = 26; + public static final byte MODIFIER_SYMBOL = 27; + public static final byte OTHER_SYMBOL = 28; + + // Format controls. + public static final byte CONTROL = 15; + // Note: The JCL book says that both FORMAT and PRIVATE_USE are 18. + // However, FORMAT is actually 16. + public static final byte FORMAT = 16; + + // Others. + public static final byte UNASSIGNED = 0; + public static final byte PRIVATE_USE = 18; + public static final byte SURROGATE = 19; + + + public Character (char ch) + { + value = ch; + } + + public char charValue () + { + return value; + } + + // See if a character is a digit. If so, return the corresponding + // value. Otherwise return -1. + private static native int digit_value (char ch); + + public static int digit (char ch, int radix) + { + if (radix < MIN_RADIX || radix > MAX_RADIX) + return -1; + + int d = digit_value (ch); + if (d == -1) + { + if (ch >= 'A' && ch <= 'Z') + d = ch - 'A' + 10; + else if (ch >= 'a' && ch <= 'z') + d = ch - 'a' + 10; + else + return -1; + } + return d >= radix ? -1 : d; + } + + public boolean equals (Object obj) + { + // Don't need to compare OBJ to null as instanceof will do this. + if (obj instanceof Character) + return value == ((Character) obj).value; + return false; + } + + public static char forDigit (int d, int rdx) + { + if (d < 0 || d >= rdx || rdx < MIN_RADIX || rdx > MAX_RADIX) + return '\u0000'; + if (d < 10) + return (char) ('0' + d); + // The Java Language Spec says to use lowercase, while the JCL + // says to use uppercase. We go with the former. + return (char) ('a' + d - 10); + } + + public static native int getNumericValue (char ch); + public static native int getType (char ch); + + public int hashCode () + { + return value; + } + + public static boolean isDefined (char ch) + { + return getType (ch) != UNASSIGNED; + } + + public static boolean isDigit (char ch) + { + return digit_value (ch) != -1; + } + + // The JCL book says that the argument here is a Character. That is + // wrong. + public static boolean isIdentifierIgnorable (char ch) + { + // This information comes from the Unicode Standard. It isn't + // auto-generated as it doesn't appear in the unidata table. + return ((ch >= '\u0000' && ch <= '\u0008') + || (ch >= '\u000e' && ch <= '\u001b') + // JDK 1.2 docs say that these are ignorable. The Unicode + // Standard is somewhat ambiguous on this issue. + || (ch >= '\u007f' && ch <= '\u009f') + || (ch >= '\u200c' && ch <= '\u200f') + // JCl says 200a through 200e, but that is a typo. The + // Unicode standard says the bidi controls are 202a + // through 202e. + || (ch >= '\u202a' && ch <= '\u202e') + || (ch >= '\u206a' && ch <= '\u206f') + || ch == '\ufeff'); + } + + public static boolean isISOControl (char c) + { + return ((c >= '\u0000' && c <= '\u001f') + || (c >= '\u007f' && c <= '\u009f')); + } + + public static boolean isJavaIdentifierPart (char ch) + { + if (isIdentifierIgnorable (ch) || isDigit (ch)) + return true; + int type = getType (ch); + return (type == COMBINING_SPACING_MARK || type == NON_SPACING_MARK + || type == CURRENCY_SYMBOL || type == CONNECTOR_PUNCTUATION + || type == UPPERCASE_LETTER || type == LOWERCASE_LETTER + || type == TITLECASE_LETTER || type == MODIFIER_LETTER + || type == OTHER_LETTER || type == LETTER_NUMBER); + } + + public static boolean isJavaIdentifierStart (char ch) + { + int type = getType (ch); + return (type == CURRENCY_SYMBOL || type == CONNECTOR_PUNCTUATION + || type == UPPERCASE_LETTER || type == LOWERCASE_LETTER + || type == TITLECASE_LETTER || type == MODIFIER_LETTER + || type == OTHER_LETTER); + } + + // Deprecated in 1.2. + public static boolean isJavaLetter (char ch) + { + return ch == '$' || ch == '_' || isLetter (ch); + } + + // Deprecated in 1.2. + public static boolean isJavaLetterOrDigit (char ch) + { + return ch == '$' || ch == '_' || isLetterOrDigit (ch); + } + + public static boolean isLetter (char ch) + { + int type = getType (ch); + return (type == UPPERCASE_LETTER || type == LOWERCASE_LETTER + || type == TITLECASE_LETTER || type == MODIFIER_LETTER + || type == OTHER_LETTER); + } + + public static boolean isLetterOrDigit (char ch) + { + return isDigit (ch) || isLetter (ch); + } + + public static native boolean isLowerCase (char ch); + + // Deprecated in JCL. + public static boolean isSpace (char ch) + { + return ch == '\n' || ch == '\t' || ch == '\f' || ch == '\r' || ch == ' '; + } + + public static native boolean isSpaceChar (char ch); + public static native boolean isTitleCase (char ch); + + public static boolean isUnicodeIdentifierPart (char ch) + { + if (isIdentifierIgnorable (ch) || isDigit (ch)) + return true; + int type = getType (ch); + return (type == CONNECTOR_PUNCTUATION || type == LETTER_NUMBER + || type == COMBINING_SPACING_MARK || type == NON_SPACING_MARK + || type == UPPERCASE_LETTER || type == LOWERCASE_LETTER + || type == TITLECASE_LETTER || type == MODIFIER_LETTER + || type == OTHER_LETTER); + } + + public static boolean isUnicodeIdentifierStart (char ch) + { + return isLetter (ch); + } + + public static native boolean isUpperCase (char ch); + + public static boolean isWhitespace (char ch) + { + return ((ch >= '\u0009' && ch <= '\r') + || (ch >= '\u001c' && ch <= '\u001f') + || (ch != '\u00a0' && ch != '\ufeff' && isSpaceChar (ch))); + } + + public static native char toLowerCase (char ch); + public static native char toTitleCase (char ch); + public static native char toUpperCase (char ch); + + public String toString () + { + return String.valueOf(value); + } + + public int compareTo (Character anotherCharacter) + { + return value - anotherCharacter.value; + } + + public int compareTo (Object o) + { + return compareTo ((Character) o); + } + + // Private data. + private char value; +} diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h new file mode 100644 index 00000000000..eb0a2f95533 --- /dev/null +++ b/libjava/java/lang/Class.h @@ -0,0 +1,214 @@ +// Class.h - Header file for java.lang.Class. -*- c++ -*- + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +// Written primary using compiler source and Class.java as guides. +#ifndef __JAVA_LANG_CLASS_H__ +#define __JAVA_LANG_CLASS_H__ + +#pragma interface + +#include +#include + +// We declare these here to avoid including cni.h. +extern "C" void _Jv_InitClass (jclass klass); +extern "C" void _Jv_RegisterClasses (jclass *classes); + +struct _Jv_Field; +struct _Jv_VTable; + +#define CONSTANT_Class 7 +#define CONSTANT_Fieldref 9 +#define CONSTANT_Methodref 10 +#define CONSTANT_InterfaceMethodref 11 +#define CONSTANT_String 8 +#define CONSTANT_Integer 3 +#define CONSTANT_Float 4 +#define CONSTANT_Long 5 +#define CONSTANT_Double 6 +#define CONSTANT_NameAndType 12 +#define CONSTANT_Utf8 1 +#define CONSTANT_Unicode 2 +#define CONSTANT_ResolvedFlag 16 +#define CONSTANT_ResolvedString (CONSTANT_String+CONSTANT_ResolvedFlag) +#define CONSTANT_ResolvedClass (CONSTANT_Class+CONSTANT_ResolvedFlag) + +struct _Jv_Constants +{ + jint size; + jbyte *tags; + void **data; +}; + +struct _Jv_Method +{ + _Jv_Utf8Const *name; + _Jv_Utf8Const *signature; + unsigned short accflags; + void *ncode; +}; + +#define JV_PRIMITIVE_VTABLE ((_Jv_VTable *) -1) + +class java::lang::Class : public java::lang::Object +{ +public: + static jclass forName (jstring className); + JArray *getClasses (void); + + java::lang::ClassLoader *getClassLoader (void) + { + return loader; + } + + jclass getComponentType (void) + { + return isArray () ? (* (jclass *) &methods) : 0; + } + + java::lang::reflect::Constructor *getConstructor (JArray *); + JArray *getConstructors (void); + java::lang::reflect::Constructor *getDeclaredConstructor (JArray *); + JArray *getDeclaredConstructors (void); + java::lang::reflect::Field *getDeclaredField (jstring); + JArray *getDeclaredFields (void); + java::lang::reflect::Method *getDeclaredMethod (jstring, JArray *); + JArray *getDeclaredMethods (void); + + JArray *getDeclaredClasses (void); + jclass getDeclaringClass (void); + + java::lang::reflect::Field *getField (jstring); +private: + java::lang::reflect::Field *getField (jstring, jint); +public: + JArray *getFields (void); + + JArray *getInterfaces (void); + + java::lang::reflect::Method *getMethod (jstring, JArray *); + JArray *getMethods (void); + + jint getModifiers (void) + { + return accflags; + } + + jstring getName (void); + + java::io::InputStream *getResourceAsStream (jstring resourceName); + JArray *getSigners (void); + + jclass getSuperclass (void) + { + return superclass; + } + + jboolean isArray (void) + { + return name->data[0] == '['; + } + + jboolean isAssignableFrom (jclass cls); + jboolean isInstance (jobject obj); + jboolean isInterface (void); + + jboolean isPrimitive (void) + { + return vtable == JV_PRIMITIVE_VTABLE; + } + + jobject newInstance (void); + jstring toString (void); + + // FIXME: this probably shouldn't be public. + jint size (void) + { + return size_in_bytes; + } + +private: + void checkMemberAccess (jint flags); + void resolveConstants (void); + + // Various functions to handle class initialization. + java::lang::Throwable *hackTrampoline (jint, java::lang::Throwable *); + void hackRunInitializers (void); + void initializeClass (void); + + // Friend functions implemented in natClass.cc. + friend _Jv_Method *_Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name, + _Jv_Utf8Const *signature); + friend void _Jv_InitClass (jclass klass); + friend void _Jv_RegisterClasses (jclass *classes); + friend jclass _Jv_FindClassInCache (_Jv_Utf8Const *name, + java::lang::ClassLoader *loader); + friend jclass _Jv_FindArrayClass (jclass element); + friend jclass _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass, + java::lang::ClassLoader *loader); + + friend jfieldID JvGetFirstInstanceField (jclass); + friend jint JvNumInstanceFields (jclass); + friend jobject _Jv_AllocObject (jclass, jint); + friend jobjectArray _Jv_NewObjectArray (jsize, jclass, jobject); + friend jobject _Jv_NewPrimArray (jclass, jint); + friend jobject _Jv_JNI_ToReflectedField (_Jv_JNIEnv *, jclass, jfieldID); + friend jfieldID _Jv_FromReflectedField (java::lang::reflect::Field *); + friend jmethodID _Jv_FromReflectedMethod (java::lang::reflect::Method *); + + friend class _Jv_PrimClass; + +#ifdef JV_MARKOBJ_DECL + friend JV_MARKOBJ_DECL; +#endif + + // Chain for class pool. + jclass next; + // Name of class. + _Jv_Utf8Const *name; + // Access flags for class. + unsigned short accflags; + // The superclass, or null for Object. + jclass superclass; + // Class constants. + _Jv_Constants constants; + // Methods. If this is an array class, then this field holds a + // pointer to the element type. If this is a primitive class, this + // is used to cache a pointer to the appropriate array type. + _Jv_Method *methods; + // Number of methods. If this class is primitive, this holds the + // character used to represent this type in a signature. + short method_count; + // Number of methods in the vtable. + short vtable_method_count; + // The fields. + _Jv_Field *fields; + // Size of instance fields, in bytes. + int size_in_bytes; + // Total number of fields (instance and static). + short field_count; + // Number of static fields. + short static_field_count; + // The vtbl for all objects of this class. + _Jv_VTable *vtable; + // Interfaces implemented by this class. + jclass *interfaces; + // The class loader for this class. + java::lang::ClassLoader *loader; + // Number of interfaces. + short interface_count; + // State of this class. + jbyte state; + // The thread which has locked this class. Used during class + // initialization. + java::lang::Thread *thread; +}; + +#endif /* __JAVA_LANG_CLASS_H__ */ diff --git a/libjava/java/lang/Class.java b/libjava/java/lang/Class.java new file mode 100644 index 00000000000..4ffcceaf675 --- /dev/null +++ b/libjava/java/lang/Class.java @@ -0,0 +1,155 @@ +// Class.java - Representation of a Java class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; +import java.io.Serializable; +import java.io.InputStream; +import java.lang.reflect.*; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * plus gcj compiler sources (to determine object layout) + * Status: Sufficient for our purposes, but some methods missing + * and some not implemented. + */ + +public final class Class implements Serializable +{ + public static native Class forName (String className) + throws ClassNotFoundException; + public native Class[] getClasses (); + public native ClassLoader getClassLoader (); + public native Class getComponentType (); + + public native Constructor getConstructor (Class[] parameterTypes) + throws NoSuchMethodException, SecurityException; + public native Constructor[] getConstructors () throws SecurityException; + + public native Class[] getDeclaredClasses () throws SecurityException; + + public native Constructor getDeclaredConstructor (Class[] parameterTypes) + throws NoSuchMethodException, SecurityException; + public native Constructor[] getDeclaredConstructors () + throws SecurityException; + public native Field getDeclaredField (String fieldName) + throws NoSuchFieldException, SecurityException; + public native Field[] getDeclaredFields () throws SecurityException; + public native Method getDeclaredMethod (String methodName, + Class[] parameterTypes) + throws NoSuchMethodException, SecurityException; + public native Method[] getDeclaredMethods () throws SecurityException; + + // This is marked as unimplemented in the JCL book. + public native Class getDeclaringClass (); + + private native Field getField (String fieldName, int hash) + throws NoSuchFieldException, SecurityException; + + public Field getField (String fieldName) + throws NoSuchFieldException, SecurityException + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkMemberAccess (this, java.lang.reflect.Member.DECLARED); + Field fld = getField(fieldName, fieldName.hashCode()); + if (fld == null) + throw new NoSuchFieldException(fieldName); + return fld; + } + public native Field[] getFields () throws SecurityException; + + public native Class[] getInterfaces (); + + public native Method getMethod (String methodName, Class[] parameterTypes) + throws NoSuchMethodException, SecurityException; + public native Method[] getMethods () throws SecurityException; + + public native int getModifiers (); + public native String getName (); + + // FIXME: can't implement this until we have java.net. + // public URL getResource (String resourceName); + + // FIXME: implement. + public InputStream getResourceAsStream (String resourceName) + { + return null; + } + + // FIXME: implement. Requires java.security. + public Object[] getSigners () + { + return null; + } + + public native Class getSuperclass (); + public native boolean isArray (); + public native boolean isAssignableFrom (Class cls); + public native boolean isInstance (Object obj); + public native boolean isInterface (); + public native boolean isPrimitive (); + public native Object newInstance () + throws InstantiationException, IllegalAccessException; + + public String toString () + { + if (isPrimitive ()) + return getName (); + return (isInterface () ? "interface " : "class ") + getName (); + } + + // Don't allow new classes to be made. + private Class () + { + } + + // Do a security check. + private void checkMemberAccess (int flags) + { + SecurityManager sm = System.getSecurityManager(); + if (sm != null) + sm.checkMemberAccess(this, flags); + } + + // FIXME: this method exists only because we cannot catch Java + // exceptions from C++ code. This is a helper for initializeClass. + private Throwable hackTrampoline (int what, Throwable old_exception) + { + Throwable new_val = null; + try + { + if (what == 0) + initializeClass (); + else if (what == 1) + hackRunInitializers (); + else if (what == 2) + new_val = new ExceptionInInitializerError (old_exception); + } + catch (Throwable t) + { + new_val = t; + } + return new_val; + } + + // FIXME: this is a hack to let us run the class initializers. We + // could do it inline in initializeClass() if we could catch Java + // exceptions from C++. + private native void hackRunInitializers (); + + // Initialize the class. + private native void initializeClass (); +} diff --git a/libjava/java/lang/ClassCastException.java b/libjava/java/lang/ClassCastException.java new file mode 100644 index 00000000000..bd5a2a49b8e --- /dev/null +++ b/libjava/java/lang/ClassCastException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ClassCastException extends RuntimeException +{ + public ClassCastException() + { + super(); + } + + public ClassCastException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/ClassCircularityError.java b/libjava/java/lang/ClassCircularityError.java new file mode 100644 index 00000000000..a5e03831805 --- /dev/null +++ b/libjava/java/lang/ClassCircularityError.java @@ -0,0 +1,34 @@ +// ClassCircularityError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ClassCircularityError extends LinkageError +{ + public ClassCircularityError () + { + super (); + } + + public ClassCircularityError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/ClassFormatError.java b/libjava/java/lang/ClassFormatError.java new file mode 100644 index 00000000000..99b8425c9be --- /dev/null +++ b/libjava/java/lang/ClassFormatError.java @@ -0,0 +1,34 @@ +// ClassFormatError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ClassFormatError extends LinkageError +{ + public ClassFormatError () + { + super (); + } + + public ClassFormatError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/ClassLoader.java b/libjava/java/lang/ClassLoader.java new file mode 100644 index 00000000000..048cea7d883 --- /dev/null +++ b/libjava/java/lang/ClassLoader.java @@ -0,0 +1,94 @@ +// ClassLoader.java - Define policies for loading Java classes. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; +import java.io.InputStream; +import java.util.Hashtable; + +/** + * @author Tom Tromey + * @date October 28, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * Status: Just a stub; not useful at all. + */ + +public abstract class ClassLoader +{ + protected ClassLoader () + { + cache = new Hashtable (); + } + + protected final Class defineClass (String className, byte[] bytecode, + int offset, int length) + { + throw new ClassFormatError ("defineClass unimplemented"); + } + + protected final Class defineClass (byte[] bytecodes, + int offset, int length) + { + return defineClass (null, bytecodes, offset, length); + } + + protected final Class findLoadedClass (String className) + { + return (Class) cache.get(className); + } + + protected final Class findSystemClass (String className) + throws ClassNotFoundException + { + Class c = system.findLoadedClass(className); + system.resolveClass(c); + return c; + } + + // FIXME: Needs URL. + // public URL getResource (String resName); + + public InputStream getResourceAsStream (String resName) + { + return null; + } + + // FIXME: Needs URL. + // public static final URL getSystemResource (String resName); + + public static final InputStream getSystemResourceAsStream (String resName) + { + return null; + } + + protected abstract Class loadClass (String className, boolean resolve) + throws ClassNotFoundException; + public Class loadClass (String name) throws ClassNotFoundException + { + return loadClass (name, true); + } + + protected final void resolveClass (Class c) + { + // Nothing for now. + } + + protected final void setSigners (Class cl, Object[] signers) + { + // Nothing for now. + } + + // Class cache. + private Hashtable cache; + + // The system class loader. FIXME: should have an actual value + private static final ClassLoader system = null; +} diff --git a/libjava/java/lang/ClassNotFoundException.java b/libjava/java/lang/ClassNotFoundException.java new file mode 100644 index 00000000000..e0ea15e22a2 --- /dev/null +++ b/libjava/java/lang/ClassNotFoundException.java @@ -0,0 +1,57 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ClassNotFoundException extends Exception +{ + public ClassNotFoundException() + { + super(); + } + + // TODO12: + // public ClassNotFoundException(String msg, Throwable ex) + // { + // } + + public ClassNotFoundException(String msg) + { + super(msg); + } + + // TODO12: + // public Throwable getException() + // { + // } + + // TBD: if this needs to be implemented + // public void printStackTrace() + // { + // } + + // TBD: if this needs to be implemented + // public void printStackTrace(PrintStream ps) + // { + // } + + // TBD: if this needs to be implemented + // public void printStackTrace(PrintWriter pw) + // { + // } +} diff --git a/libjava/java/lang/CloneNotSupportedException.java b/libjava/java/lang/CloneNotSupportedException.java new file mode 100644 index 00000000000..155e80481a9 --- /dev/null +++ b/libjava/java/lang/CloneNotSupportedException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class CloneNotSupportedException extends Exception +{ + public CloneNotSupportedException() + { + super(); + } + + public CloneNotSupportedException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/Cloneable.java b/libjava/java/lang/Cloneable.java new file mode 100644 index 00000000000..730e5c91b5f --- /dev/null +++ b/libjava/java/lang/Cloneable.java @@ -0,0 +1,23 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public interface Cloneable +{ +} diff --git a/libjava/java/lang/Comparable.java b/libjava/java/lang/Comparable.java new file mode 100644 index 00000000000..e40e6e81ae8 --- /dev/null +++ b/libjava/java/lang/Comparable.java @@ -0,0 +1,22 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 8, 1998. + */ +/* Written using online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public interface Comparable +{ + public int compareTo(Object o) throws ClassCastException; +} diff --git a/libjava/java/lang/Compiler.java b/libjava/java/lang/Compiler.java new file mode 100644 index 00000000000..7feb9f86429 --- /dev/null +++ b/libjava/java/lang/Compiler.java @@ -0,0 +1,53 @@ +// Compiler.java - Control byte->machine code compiler. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 23, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + */ + +public final class Compiler +{ + public static Object command (Object arg) + { + // Our implementation defines this to a no-op. + return null; + } + + public static boolean compileClass (Class oneClass) + { + // Never succeed. + return false; + } + + public static boolean compileClasses (String classNames) + { + // Note the incredibly lame interface. Always fail. + return false; + } + + public static void disable () + { + } + + public static void enable () + { + } + + // Don't allow new `Compiler's to be made. + private Compiler () + { + } +} diff --git a/libjava/java/lang/Double.java b/libjava/java/lang/Double.java new file mode 100644 index 00000000000..850aa5ad979 --- /dev/null +++ b/libjava/java/lang/Double.java @@ -0,0 +1,149 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Andrew Haley + * @date September 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public final class Double extends Number +{ + public static final double MIN_VALUE = 5e-324; + public static final double MAX_VALUE = 1.7976931348623157e+308; + public static final double NEGATIVE_INFINITY = -1.0d/0.0d; + public static final double POSITIVE_INFINITY = 1.0d/0.0d; + public static final double NaN = 0.0d/0.0d; + + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public static final Class TYPE = double.class; + + private double value; + + private native static double doubleValueOf (String s) + throws NumberFormatException; + + public Double (double v) + { + value = v; + } + + public Double (String s) throws NumberFormatException + { + value = valueOf (s).doubleValue (); + } + + public String toString () + { + return toString (value); + } + + public boolean equals (Object obj) + { + if (obj == null) + return false; + + if (!(obj instanceof Double)) + return false; + + Double d = (Double) obj; + + return doubleToLongBits (value) == doubleToLongBits (d.doubleValue ()); + } + + public int hashCode () + { + long v = doubleToLongBits (value); + return (int) (v ^ (v >>> 32)); + } + + public int intValue () + { + return (int) value; + } + + public long longValue () + { + return (long) value; + } + + public float floatValue () + { + return (float) value; + } + + public double doubleValue () + { + return value; + } + + public byte byteValue () + { + return (byte) value; + } + + public short shortValue () + { + return (short) value; + } + + native static String toString (double v, boolean isFloat); + + public static String toString (double v) + { + return toString (v, false); + } + + public static Double valueOf (String s) throws NullPointerException, + NumberFormatException + { + if (s == null) + throw new NullPointerException (); + + return new Double (doubleValueOf (s)); + } + + public boolean isNaN () + { + return isNaN (value); + } + + public static boolean isNaN (double v) + { + long bits = doubleToLongBits (v); + long e = bits & 0x7ff0000000000000L; + long f = bits & 0x000fffffffffffffL; + + return e == 0x7ff0000000000000L && f != 0L; + } + + public boolean isInfinite () + { + return isInfinite (value); + } + + public static boolean isInfinite (double v) + { + long bits = doubleToLongBits (v); + long f = bits & 0x7fffffffffffffffL; + + return f == 0x7ff0000000000000L; + } + + public static native long doubleToLongBits (double value); + + public static native double longBitsToDouble (long bits); +} + diff --git a/libjava/java/lang/Error.java b/libjava/java/lang/Error.java new file mode 100644 index 00000000000..ef69f0ea413 --- /dev/null +++ b/libjava/java/lang/Error.java @@ -0,0 +1,34 @@ +// Error.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class Error extends Throwable +{ + public Error () + { + super (); + } + + public Error (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/Exception.java b/libjava/java/lang/Exception.java new file mode 100644 index 00000000000..8eb5e44dc36 --- /dev/null +++ b/libjava/java/lang/Exception.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class Exception extends Throwable +{ + public Exception() + { + super(); + } + + public Exception(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/ExceptionInInitializerError.java b/libjava/java/lang/ExceptionInInitializerError.java new file mode 100644 index 00000000000..deb1213e3b2 --- /dev/null +++ b/libjava/java/lang/ExceptionInInitializerError.java @@ -0,0 +1,50 @@ +// ExceptionInInitializerError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ExceptionInInitializerError extends LinkageError +{ + public ExceptionInInitializerError () + { + super (); + exception = null; + } + + public ExceptionInInitializerError (String msg) + { + super (msg); + exception = null; + } + + public ExceptionInInitializerError (Throwable e) + { + super (); + exception = e; + } + + public Throwable getException () + { + return exception; + } + + // The exception that caused this error. + private Throwable exception; +} diff --git a/libjava/java/lang/FirstThread.java b/libjava/java/lang/FirstThread.java new file mode 100644 index 00000000000..ec0f1db33d5 --- /dev/null +++ b/libjava/java/lang/FirstThread.java @@ -0,0 +1,40 @@ +// FirstThread.java - Implementation of very first thread. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date August 24, 1998 + */ + +// This is entirely internal to our implementation. + +final class FirstThread extends Thread +{ + public native void run (); + + public FirstThread (ThreadGroup g, Class k, Object o) + { + super (g, null, "main"); + klass = k; + args = o; + } + + private static void die (String s) + { + System.err.println(s); + System.exit(1); + } + + // Private data. + private Class klass; + private Object args; +} diff --git a/libjava/java/lang/Float.java b/libjava/java/lang/Float.java new file mode 100644 index 00000000000..99cc66bc8e7 --- /dev/null +++ b/libjava/java/lang/Float.java @@ -0,0 +1,149 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Andrew Haley + * @date September 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public final class Float extends Number +{ + public static final float MAX_VALUE = 3.4028235e+38f; + public static final float MIN_VALUE = 1.4e-45f; + public static final float NEGATIVE_INFINITY = -1.0f/0.0f; + public static final float POSITIVE_INFINITY = 1.0f/0.0f; + public static final float NaN = 0.0f/0.0f; + + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public static final Class TYPE = float.class; + + private float value; + + public Float (float value) + { + this.value = value; + } + + public Float (double value) + { + this.value = (float)value; + } + + public Float (String s) throws NumberFormatException + { + this.value = valueOf (s).floatValue (); + } + + public String toString () + { + return toString (value); + } + + public boolean equals (Object obj) + { + if (obj == null) + return false; + + if (!(obj instanceof Float)) + return false; + + Float f = (Float) obj; + + return floatToIntBits (value) == floatToIntBits (f.floatValue ()); + } + + public int hashCode () + { + return floatToIntBits (value); + } + + public int intValue () + { + return (int) value; + } + + public long longValue () + { + return (long) value; + } + + public float floatValue () + { + return (float) value; + } + + public double doubleValue () + { + return (double) value; + } + + public byte byteValue () + { + return (byte) value; + } + + public short shortValue () + { + return (short) value; + } + + public static String toString (float v) + { + return Double.toString ((double) v, true); + } + + public static Float valueOf (String s) throws NullPointerException, + NumberFormatException + { + if (s == null) + throw new NullPointerException (); + + return new Float (Double.valueOf (s).floatValue ()); + } + + public boolean isNaN () + { + return isNaN (value); + } + + public static boolean isNaN (float v) + { + int bits = floatToIntBits (v); + int e = bits & 0x7f800000; + int f = bits & 0x007fffff; + + return e == 0x7f800000 && f != 0; + } + + public boolean isInfinite () + { + return isInfinite (value); + } + + public static boolean isInfinite (float v) + { + int bits = floatToIntBits (v); + int f = bits & 0x7fffffff; + + return f == 0x7f800000; + } + + public static native int floatToIntBits (float value); + + public static native float intBitsToFloat (int bits); + +} + diff --git a/libjava/java/lang/IllegalAccessError.java b/libjava/java/lang/IllegalAccessError.java new file mode 100644 index 00000000000..2d863416eb5 --- /dev/null +++ b/libjava/java/lang/IllegalAccessError.java @@ -0,0 +1,34 @@ +// IllegalAccessError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class IllegalAccessError extends IncompatibleClassChangeError +{ + public IllegalAccessError () + { + super (); + } + + public IllegalAccessError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/IllegalAccessException.java b/libjava/java/lang/IllegalAccessException.java new file mode 100644 index 00000000000..c07a518779a --- /dev/null +++ b/libjava/java/lang/IllegalAccessException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class IllegalAccessException extends Exception +{ + public IllegalAccessException() + { + super(); + } + + public IllegalAccessException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/IllegalArgumentException.java b/libjava/java/lang/IllegalArgumentException.java new file mode 100644 index 00000000000..6e8f0ed0300 --- /dev/null +++ b/libjava/java/lang/IllegalArgumentException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class IllegalArgumentException extends RuntimeException +{ + public IllegalArgumentException() + { + super(); + } + + public IllegalArgumentException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/IllegalMonitorStateException.java b/libjava/java/lang/IllegalMonitorStateException.java new file mode 100644 index 00000000000..f431749ca5f --- /dev/null +++ b/libjava/java/lang/IllegalMonitorStateException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class IllegalMonitorStateException extends RuntimeException +{ + public IllegalMonitorStateException() + { + super(); + } + + public IllegalMonitorStateException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/IllegalStateException.java b/libjava/java/lang/IllegalStateException.java new file mode 100644 index 00000000000..2ea0d02b62b --- /dev/null +++ b/libjava/java/lang/IllegalStateException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class IllegalStateException extends RuntimeException +{ + public IllegalStateException() + { + super(); + } + + public IllegalStateException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/IllegalThreadStateException.java b/libjava/java/lang/IllegalThreadStateException.java new file mode 100644 index 00000000000..72afa771ede --- /dev/null +++ b/libjava/java/lang/IllegalThreadStateException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class IllegalThreadStateException extends IllegalArgumentException +{ + public IllegalThreadStateException() + { + super(); + } + + public IllegalThreadStateException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/IncompatibleClassChangeError.java b/libjava/java/lang/IncompatibleClassChangeError.java new file mode 100644 index 00000000000..31a22c46175 --- /dev/null +++ b/libjava/java/lang/IncompatibleClassChangeError.java @@ -0,0 +1,34 @@ +// IncompatibleClassChangeError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class IncompatibleClassChangeError extends LinkageError +{ + public IncompatibleClassChangeError () + { + super (); + } + + public IncompatibleClassChangeError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/IndexOutOfBoundsException.java b/libjava/java/lang/IndexOutOfBoundsException.java new file mode 100644 index 00000000000..c8b5878b3d8 --- /dev/null +++ b/libjava/java/lang/IndexOutOfBoundsException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class IndexOutOfBoundsException extends RuntimeException +{ + public IndexOutOfBoundsException() + { + super(); + } + + public IndexOutOfBoundsException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/InstantiationError.java b/libjava/java/lang/InstantiationError.java new file mode 100644 index 00000000000..7982615e8f6 --- /dev/null +++ b/libjava/java/lang/InstantiationError.java @@ -0,0 +1,34 @@ +// InstantiationError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class InstantiationError extends IncompatibleClassChangeError +{ + public InstantiationError () + { + super (); + } + + public InstantiationError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/InstantiationException.java b/libjava/java/lang/InstantiationException.java new file mode 100644 index 00000000000..d5ca893fe02 --- /dev/null +++ b/libjava/java/lang/InstantiationException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class InstantiationException extends Exception +{ + public InstantiationException() + { + super(); + } + + public InstantiationException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/Integer.java b/libjava/java/lang/Integer.java new file mode 100644 index 00000000000..54acc27ed6b --- /dev/null +++ b/libjava/java/lang/Integer.java @@ -0,0 +1,355 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 11, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public final class Integer extends Number implements Comparable +{ + public static final int MAX_VALUE = 0x7FFFFFFF; + public static final int MIN_VALUE = 0x80000000; + + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public static final Class TYPE = int.class; + + /* The int value of the instance. */ + private int value; + + public Integer(int val) + { + value = val; + } + + public Integer(String str) throws NumberFormatException + { + value = parseInt(str, 10); + } + + public byte byteValue() + { + return (byte) value; + } + + public double doubleValue() + { + return (double) value; + } + + public float floatValue() + { + return (float) value; + } + + public int intValue() + { + return value; + } + + public long longValue() + { + return value; + } + + public short shortValue() + { + return (short) value; + } + + // Added in JDK 1.2 + public int compareTo(Integer anotherInteger) + { + if (this.value == anotherInteger.value) + return 0; + + // Returns just -1 or 1 on inequality; doing math might overflow the int. + if (this.value > anotherInteger.value) + return 1; + + return -1; + } + + // Added in JDK 1.2 + public int compareTo(Object o) throws ClassCastException + { + if (!(o instanceof Integer)) + throw new ClassCastException(); + + return this.compareTo((Integer) o); + } + + public static Integer decode(String str) throws NumberFormatException + { + boolean isNeg = false; + int index = 0; + int radix = 10; + final int len; + + if (str == null || (len = str.length()) == 0) + throw new NumberFormatException(); + + // Negative numbers are always radix 10. + if (str.charAt(0) == '-') + { + radix = 10; + index++; + isNeg = true; + } + else if (str.charAt(index) == '#') + { + radix = 16; + index++; + } + else if (str.charAt(index) == '0') + { + // Check if str is just "0" + if (len == 1) + return new Integer(0); + + index++; + if (str.charAt(index) == 'x') + { + radix = 16; + index++; + } + else + radix = 8; + } + + if (index >= len) + throw new NumberFormatException(); + + return new Integer(parseInt(str, index, len, isNeg, radix)); + } + + public boolean equals(Object obj) + { + return (obj != null && (obj instanceof Integer) + && ((Integer) obj).value == value); + } + + public static Integer getInteger(String prop) + { + return getInteger(prop, null); + } + + public static Integer getInteger(String prop, int defval) + { + Integer val = getInteger(prop, null); + return val == null ? new Integer(defval) : val; + } + + public static Integer getInteger(String prop, Integer defobj) + { + try + { + return decode(System.getProperty(prop)); + } + catch (NumberFormatException ex) + { + return defobj; + } + } + + public int hashCode() + { + return value; + } + + public static int parseInt(String str) throws NumberFormatException + { + return parseInt(str, 10); + } + + public static int parseInt(String str, int radix) throws NumberFormatException + { + final int len; + + if (str == null || (len = str.length()) == 0 || + radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) + throw new NumberFormatException(); + + boolean isNeg = false; + int index = 0; + if (str.charAt(index) == '-') + if (len > 1) + { + isNeg = true; + index++; + } + else + throw new NumberFormatException(); + + return parseInt(str, index, len, isNeg, radix); + } + + private static int parseInt(String str, int index, int len, boolean isNeg, + int radix) throws NumberFormatException + { + int val = 0; + int digval; + + for ( ; index < len; index++) + { + // The the previous loop iteration left us with a negative + // value (which can only be the most negative value, but we + // don't check that), then having more digits is wrong. + if (val == MIN_VALUE) + throw new NumberFormatException(); + + if ((digval = Character.digit(str.charAt(index), radix)) < 0) + throw new NumberFormatException(); + + // Throw an exception for overflow if result is negative. + // However, we special-case the most negative value. + val *= radix; + if (val < 0 || val + digval < 0) + { + if (isNeg && val + digval == MIN_VALUE) + { + // Ok. + } + else + throw new NumberFormatException(); + } + val += digval; + } + + return isNeg ? -(val) : val; + } + + public static String toBinaryString(int num) + { + return toUnsignedString(num, 1); + } + + public static String toHexString(int num) + { + return toUnsignedString(num, 4); + } + + public static String toOctalString(int num) + { + return toUnsignedString(num, 3); + } + + private static String toUnsignedString(int num, int exp) + { + // Use an array large enough for a binary number. + int radix = 1 << exp; + int mask = radix - 1; + char[] buffer = new char[32]; + int i = 32; + do + { + buffer[--i] = Character.forDigit(num & mask, radix); + num = num >>> exp; + } + while (num != 0); + + return String.valueOf(buffer, i, 32-i); + } + + public String toString() + { + return toString(this.value); + } + + public static String toString(int num) + { + // Use an arrary large enough for "-2147483648"; i.e. 11 chars. + char[] buffer = new char[11]; + int i = 11; + boolean isNeg; + if (num < 0) + { + isNeg = true; + num = -(num); + if (num < 0) + { + // Must be MIN_VALUE, so handle this special case. + buffer[--i] = '8'; + num = 214748364; + } + } + else + isNeg = false; + + do + { + buffer[--i] = (char) ((int) '0' + (num % 10)); + num /= 10; + } + while (num > 0); + + if (isNeg) + buffer[--i] = '-'; + + return String.valueOf(buffer, i, 11-i); + } + + public static String toString(int num, int radix) + { + // Use optimized method for the typical case. + if (radix == 10 || + radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) + return toString(num); + + // For negative numbers, print out the absolute value w/ a leading '-'. + // Use an array large enough for a binary number. + char[] buffer = new char[33]; + int i = 33; + boolean isNeg; + if (num < 0) + { + isNeg = true; + num = -(num); + + // When the value is MIN_VALUE, it overflows when made positive + if (num < 0) + { + buffer[--i] = Character.forDigit(-(num + radix) % radix, radix); + num = -(num / radix); + } + } + else + isNeg = false; + + do + { + buffer[--i] = Character.forDigit(num % radix, radix); + num /= radix; + } + while (num > 0); + + if (isNeg) + buffer[--i] = '-'; + + return String.valueOf(buffer, i, 33-i); + } + + public static Integer valueOf(String str) throws NumberFormatException + { + return new Integer(parseInt(str, 10)); + } + + public static Integer valueOf(String str, int radix) + throws NumberFormatException + { + return new Integer(parseInt(str, radix)); + } +} diff --git a/libjava/java/lang/InternalError.java b/libjava/java/lang/InternalError.java new file mode 100644 index 00000000000..6e484cfa6d0 --- /dev/null +++ b/libjava/java/lang/InternalError.java @@ -0,0 +1,34 @@ +// InternalError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class InternalError extends VirtualMachineError +{ + public InternalError () + { + super (); + } + + public InternalError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/InterruptedException.java b/libjava/java/lang/InterruptedException.java new file mode 100644 index 00000000000..ef2e9b3adaf --- /dev/null +++ b/libjava/java/lang/InterruptedException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class InterruptedException extends Exception +{ + public InterruptedException() + { + super(); + } + + public InterruptedException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/LinkageError.java b/libjava/java/lang/LinkageError.java new file mode 100644 index 00000000000..c9386a7c3c1 --- /dev/null +++ b/libjava/java/lang/LinkageError.java @@ -0,0 +1,34 @@ +// LinkageError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class LinkageError extends Error +{ + public LinkageError () + { + super (); + } + + public LinkageError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/Long.java b/libjava/java/lang/Long.java new file mode 100644 index 00000000000..1ee8bf36277 --- /dev/null +++ b/libjava/java/lang/Long.java @@ -0,0 +1,366 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public final class Long extends Number implements Comparable +{ + public static final long MAX_VALUE = 0x7FFFFFFFFFFFFFFFL; + public static final long MIN_VALUE = 0x8000000000000000L; + + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public static final Class TYPE = long.class; + + /* The long value of the instance. */ + private long value; + + public Long(long val) + { + value = val; + } + + public Long(String str) throws NumberFormatException + { + value = parseLong(str, 10); + } + + public byte byteValue() + { + return (byte) value; + } + + public double doubleValue() + { + return (double) value; + } + + public float floatValue() + { + return (float) value; + } + + public int intValue() + { + return (int) value; + } + + public long longValue() + { + return value; + } + + public short shortValue() + { + return (short) value; + } + + // Added in JDK 1.2 + public int compareTo(Long anotherLong) + { + if (this.value == anotherLong.value) + return 0; + + // Returns just -1 or 1 on inequality; doing math might overflow the long. + if (this.value > anotherLong.value) + return 1; + + return -1; + } + + // Added in JDK 1.2 + public int compareTo(Object o) throws ClassCastException + { + if (!(o instanceof Long)) + throw new ClassCastException(); + + return this.compareTo((Long) o); + } + + // Added in JDK 1.2 + public static Long decode(String str) throws NumberFormatException + { + boolean isNeg = false; + int index = 0; + int radix = 10; + final int len; + + if (str == null || (len = str.length()) == 0) + throw new NumberFormatException(); + + // Negative numbers are always radix 10. + if (str.charAt(0) == '-') + { + radix = 10; + index++; + isNeg = true; + } + else if (str.charAt(index) == '#') + { + radix = 16; + index++; + } + else if (str.charAt(index) == '0') + { + // Check if str is just "0" + if (len == 1) + return new Long(0L); + + index++; + if (str.charAt(index) == 'x') + { + radix = 16; + index++; + } + else + radix = 8; + } + + if (index >= len) + throw new NumberFormatException(); + + return new Long(parseLong(str, index, len, isNeg, radix)); + } + + public boolean equals(Object obj) + { + return (obj != null && (obj instanceof Long) + && ((Long) obj).value == value); + } + + public static Long getLong(String prop) + { + return getLong(prop, null); + } + + public static Long getLong(String prop, long defval) + { + Long val = getLong(prop, null); + return val == null ? new Long(defval) : val; + } + + public static Long getLong(String prop, Long defobj) + { + try + { + return decode(System.getProperty(prop)); + } + catch (NumberFormatException ex) + { + return defobj; + } + } + + public int hashCode() + { + return (int)(this.longValue()^(this.longValue()>>>32)); + } + + public static long parseLong(String str) throws NumberFormatException + { + return parseLong(str, 10); + } + + public static long parseLong(String str, int radix) + throws NumberFormatException + { + final int len; + + if (str == null || (len = str.length()) == 0 || + radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) + throw new NumberFormatException(); + + boolean isNeg = false; + int index = 0; + if (str.charAt(index) == '-') + if (len > 1) + { + isNeg = true; + index++; + } + else + throw new NumberFormatException(); + + return parseLong(str, index, len, isNeg, radix); + } + + private static long parseLong(String str, int index, int len, boolean isNeg, + int radix) throws NumberFormatException + { + long val = 0; + int digval; + + for ( ; index < len; index++) + { + // The the previous loop iteration left us with a negative + // value (which can only be the most negative value, but we + // don't check that), then having more digits is wrong. + if (val == MIN_VALUE) + throw new NumberFormatException(); + + if ((digval = Character.digit(str.charAt(index), radix)) < 0) + throw new NumberFormatException(); + + // Throw an exception for overflow if result is negative. + // However, we special-case the most negative value. + val *= radix; + if (val < 0 || val + digval < 0) + { + if (isNeg && val + digval == MIN_VALUE) + { + // Ok. + } + else + throw new NumberFormatException(); + } + val += digval; + } + + return isNeg ? -(val) : val; + } + + public static String toBinaryString(long num) + { + return toUnsignedString(num, 1); + } + + public static String toHexString(long num) + { + return toUnsignedString(num, 4); + } + + public static String toOctalString(long num) + { + return toUnsignedString(num, 3); + } + + private static String toUnsignedString(long num, int exp) + { + // Use an array large enough for a binary number. + int radix = 1 << exp; + long mask = radix - 1; + char[] buffer = new char[64]; + int i = 64; + do + { + buffer[--i] = Character.forDigit((int) (num & mask), radix); + num = num >>> exp; + } + while (num != 0); + + return String.valueOf(buffer, i, 64-i); + } + + public String toString() + { + return toString(this.value); + } + + public static String toString(long num) + { + // Use the Integer toString for efficiency if possible. + if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE) + return Integer.toString((int) num); + + // Use an arrary large enough for "-9223372036854775808"; i.e. 11 chars. + char[] buffer = new char[20]; + int i = 20; + boolean isNeg; + if (num < 0) + { + isNeg = true; + num = -(num); + if (num < 0) + { + // Must be MIN_VALUE, so handle this special case. + buffer[--i] = '8'; + num = 922337203685477580L; + } + } + else + isNeg = false; + + do + { + buffer[--i] = (char) ((int) '0' + (num % 10)); + num /= 10; + } + while (num > 0); + + if (isNeg) + buffer[--i] = '-'; + + return String.valueOf(buffer, i, 20-i); + } + + public static String toString(long num, int radix) + { + // Use optimized method for the typical case. + if (radix == 10 || + radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) + return toString(num); + + // Use the Integer toString for efficiency if possible. + if (num <= Integer.MAX_VALUE && num >= Integer.MIN_VALUE) + return Integer.toString((int) num, radix); + + // For negative numbers, print out the absolute value w/ a leading '-'. + // Use an array large enough for a binary number. + char[] buffer = new char[65]; + int i = 65; + boolean isNeg; + if (num < 0) + { + isNeg = true; + num = -(num); + + // When the value is MIN_VALUE, it overflows when made positive + if (num < 0) + { + buffer[--i] = Character.forDigit((int) (-(num + radix) % radix), + radix); + num = -(num / radix); + } + } + else + isNeg = false; + + do + { + buffer[--i] = Character.forDigit((int) (num % radix), radix); + num /= radix; + } + while (num > 0); + + if (isNeg) + buffer[--i] = '-'; + + return String.valueOf(buffer, i, 65-i); + } + + public static Long valueOf(String str) throws NumberFormatException + { + return new Long(parseLong(str, 10)); + } + + public static Long valueOf(String str, int radix) + throws NumberFormatException + { + return new Long(parseLong(str, radix)); + } +} diff --git a/libjava/java/lang/Math.java b/libjava/java/lang/Math.java new file mode 100644 index 00000000000..77c00bd2fd5 --- /dev/null +++ b/libjava/java/lang/Math.java @@ -0,0 +1,118 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/** + * @author Andrew Haley + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +package java.lang; + +import java.util.Random; + +public final class Math +{ + private static Random random_; + + public static final double E = 2.7182818284590452354; + public static final double PI = 3.14159265358979323846; + + public static native double sin (double x); + + public static native double cos (double x); + + public static native double tan (double x); + + public static native double asin (double x); + + public static native double acos (double x); + + public static native double atan (double x); + + public static native double atan2(double y, double x); + + public static native double exp (double x); + + public static native double log (double x); + + public static native double sqrt (double x); + + public static native double pow (double x, double y); + + public static native double IEEEremainder (double x, double y); + + public static native double ceil (double x); + + public static native double floor (double x); + + public static native double rint (double x); + + public static native int round (float x); + + public static native long round (double x); + + public static synchronized double random () + { + if (random_ == null) + random_ = new Random (); + return random_.nextDouble (); + } + + public static int abs (int n) + { + return (n < 0 ? -n : n); + } + + public static long abs (long n) + { + return (n < 0 ? -n : n); + } + + public static native float abs (float x); + + public static native double abs (double x); + + public static int min (int a, int b) + { + return (a < b ? a : b); + } + + public static long min (long a, long b) + { + return (a < b ? a : b); + } + + public static native float min (float a, float b); + + public static native double min (double a, double b); + + public static int max (int a, int b) + { + return (a < b ? b : a); + } + + public static long max (long a, long b) + { + return (a < b ? b : a); + } + + public static native float max (float a, float b); + + public static native double max (double a, double b); + + // Don't allow objects to be made. + private Math () + { + } +} + diff --git a/libjava/java/lang/NegativeArraySizeException.java b/libjava/java/lang/NegativeArraySizeException.java new file mode 100644 index 00000000000..838f408e49c --- /dev/null +++ b/libjava/java/lang/NegativeArraySizeException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NegativeArraySizeException extends RuntimeException +{ + public NegativeArraySizeException() + { + super(); + } + + public NegativeArraySizeException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/NoClassDefFoundError.java b/libjava/java/lang/NoClassDefFoundError.java new file mode 100644 index 00000000000..4368d35baa4 --- /dev/null +++ b/libjava/java/lang/NoClassDefFoundError.java @@ -0,0 +1,34 @@ +// NoClassDefFoundError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NoClassDefFoundError extends LinkageError +{ + public NoClassDefFoundError () + { + super (); + } + + public NoClassDefFoundError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/NoSuchFieldError.java b/libjava/java/lang/NoSuchFieldError.java new file mode 100644 index 00000000000..13165e89798 --- /dev/null +++ b/libjava/java/lang/NoSuchFieldError.java @@ -0,0 +1,34 @@ +// NoSuchFieldError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NoSuchFieldError extends IncompatibleClassChangeError +{ + public NoSuchFieldError () + { + super (); + } + + public NoSuchFieldError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/NoSuchFieldException.java b/libjava/java/lang/NoSuchFieldException.java new file mode 100644 index 00000000000..6e51cdad739 --- /dev/null +++ b/libjava/java/lang/NoSuchFieldException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NoSuchFieldException extends Exception +{ + public NoSuchFieldException() + { + super(); + } + + public NoSuchFieldException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/NoSuchMethodError.java b/libjava/java/lang/NoSuchMethodError.java new file mode 100644 index 00000000000..2c4c1da9f05 --- /dev/null +++ b/libjava/java/lang/NoSuchMethodError.java @@ -0,0 +1,34 @@ +// NoSuchMethodError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NoSuchMethodError extends IncompatibleClassChangeError +{ + public NoSuchMethodError () + { + super (); + } + + public NoSuchMethodError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/NoSuchMethodException.java b/libjava/java/lang/NoSuchMethodException.java new file mode 100644 index 00000000000..9861777c77d --- /dev/null +++ b/libjava/java/lang/NoSuchMethodException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NoSuchMethodException extends Exception +{ + public NoSuchMethodException() + { + super(); + } + + public NoSuchMethodException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/NullPointerException.java b/libjava/java/lang/NullPointerException.java new file mode 100644 index 00000000000..1d1abdd148c --- /dev/null +++ b/libjava/java/lang/NullPointerException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NullPointerException extends RuntimeException +{ + public NullPointerException() + { + super(); + } + + public NullPointerException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/Number.java b/libjava/java/lang/Number.java new file mode 100644 index 00000000000..bf9306b45f3 --- /dev/null +++ b/libjava/java/lang/Number.java @@ -0,0 +1,39 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +import java.io.Serializable; + +/** + * @author Warren Levy + * @date September 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public abstract class Number implements Serializable +{ + public byte byteValue() // Became non-abstract in JDK 1.2 + { + return (byte) intValue(); + } + + public abstract double doubleValue(); + public abstract float floatValue(); + public abstract int intValue(); + public abstract long longValue(); + + public short shortValue() // Became non-abstract in JDK 1.2 + { + return (short) intValue(); + } +} diff --git a/libjava/java/lang/NumberFormatException.java b/libjava/java/lang/NumberFormatException.java new file mode 100644 index 00000000000..c05a8f172d4 --- /dev/null +++ b/libjava/java/lang/NumberFormatException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NumberFormatException extends IllegalArgumentException +{ + public NumberFormatException() + { + super(); + } + + public NumberFormatException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/Object.h b/libjava/java/lang/Object.h new file mode 100644 index 00000000000..c5d55f17833 --- /dev/null +++ b/libjava/java/lang/Object.h @@ -0,0 +1,79 @@ +// Object.h - Header file for java.lang.Object. -*- c++ -*- + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#ifndef __JAVA_LANG_OBJECT_H__ +#define __JAVA_LANG_OBJECT_H__ + +#pragma interface + +#include +#include +#include +#include + +// This class is mainly here as a kludge to get G++ to allocate +// vtable pointer as the *first* word of each Object, instead of +// the second word (following sync_info). Note that various pieces of +// code know that finalize() is the first method. For instance, +// Object.java knows this, as does _Jv_AllocObject. + +struct _JvObjectPrefix +{ +protected: + // This is disguised as the C++ vtbl. + // _Jv_VTable* vtable; + + virtual void finalize () = 0; +}; + +class java::lang::Object : public _JvObjectPrefix +{ +public: + // Order must match order in Object.java. + jclass getClass (void); + virtual jint hashCode (void); + void notify (void); + void notifyAll (void); + void wait (jlong timeout, jint nanos); + virtual jboolean equals (jobject obj); + Object (void); + virtual jstring toString (void); + void wait (void); + void wait (jlong timeout); + + friend jint _Jv_MonitorEnter (jobject obj); + friend jint _Jv_MonitorExit (jobject obj); + friend void _Jv_InitializeSyncMutex (void); + friend void _Jv_FinalizeObject (jobject obj); + +#ifdef JV_MARKOBJ_DECL + friend JV_MARKOBJ_DECL; +#endif +#ifdef JV_MARKARRAY_DECL + friend JV_MARKARRAY_DECL; +#endif + +protected: + virtual jobject clone (void); + virtual void finalize (void); + +private: + // This does not actually refer to a Java object. Instead it is a + // placeholder for a piece of internal data (the synchronization + // information). + jobject sync_info; + + // Initialize the sync_info field. + void sync_init (void); + + static void hack12_6 (jobject f); +}; + +#endif /* __JAVA_LANG_OBJECT_H__ */ diff --git a/libjava/java/lang/Object.java b/libjava/java/lang/Object.java new file mode 100644 index 00000000000..2adad290812 --- /dev/null +++ b/libjava/java/lang/Object.java @@ -0,0 +1,86 @@ +// Object.java - The root of all evil. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date September 30, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * plus gcj compiler sources (to determine object layout) + * Status: Complete to version 1.1 + */ + +public class Object +{ + // This must come first. See _JvObjectPrefix in Object.h. + protected void finalize () throws Throwable + { + } + + public final native Class getClass (); + public native int hashCode (); + public final native void notify (); + public final native void notifyAll (); + public final native void wait (long timeout, int nanos) + throws InterruptedException; + + public boolean equals (Object obj) + { + return this == obj; + } + + public Object () + { + } + + public String toString () + { + return getClass().getName() + '@' + Integer.toHexString(hashCode()); + } + + public final void wait () throws InterruptedException + { + wait (0, 0); + } + + public final void wait (long timeout) throws InterruptedException + { + wait (timeout, 0); + } + + protected native Object clone () throws CloneNotSupportedException; + + // This initializes the sync_info member. It is here for + // completeness (some day we'll be able to auto-generate Object.h). + private final native void sync_init (); + + // This exists as a workaround for the fact that we can't catch a + // Java Exception from C++. This is from section 12.6 of the Java + // Language Spec. FIXME: remove this once exception processing + // works. + private static final void hack12_6 (Object f) + { + try + { + f.finalize(); + } + catch (Throwable x) + { + } + } + + // Note that we don't mention the sync_info field here. If we do, + // jc1 will not work correctly. +} diff --git a/libjava/java/lang/OutOfMemoryError.java b/libjava/java/lang/OutOfMemoryError.java new file mode 100644 index 00000000000..418e13ccbce --- /dev/null +++ b/libjava/java/lang/OutOfMemoryError.java @@ -0,0 +1,34 @@ +// OutOfMemoryError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class OutOfMemoryError extends VirtualMachineError +{ + public OutOfMemoryError () + { + super (); + } + + public OutOfMemoryError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/Process.java b/libjava/java/lang/Process.java new file mode 100644 index 00000000000..765bc9bb8bd --- /dev/null +++ b/libjava/java/lang/Process.java @@ -0,0 +1,30 @@ +// Process.java - Represent spawned system process. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; +import java.io.*; + +/** + * @author Tom Tromey + * @date October 23, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + */ + +public abstract class Process +{ + abstract public void destroy (); + abstract public int exitValue (); + abstract public InputStream getErrorStream (); + abstract public InputStream getInputStream (); + abstract public OutputStream getOutputStream (); + abstract public int waitFor () throws InterruptedException; +} diff --git a/libjava/java/lang/Runnable.java b/libjava/java/lang/Runnable.java new file mode 100644 index 00000000000..8e27d91856d --- /dev/null +++ b/libjava/java/lang/Runnable.java @@ -0,0 +1,27 @@ +// Runnable.java - Runnable interface. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date August 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Complete. + */ + +public interface Runnable +{ + public abstract void run (); +} diff --git a/libjava/java/lang/Runtime.java b/libjava/java/lang/Runtime.java new file mode 100644 index 00000000000..baf1ae541b7 --- /dev/null +++ b/libjava/java/lang/Runtime.java @@ -0,0 +1,136 @@ +// Runtime.java - Runtime class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +/** + * @author Tom Tromey + * @date August 27, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: All 1.1 methods exist. exec(), load(), and loadLibrary() + * are not fully implemented. + */ + +public class Runtime +{ + public Process exec (String prog) throws IOException + { + String[] a = new String[1]; + a[0] = prog; + return exec (a, null); + } + + public Process exec (String prog, String[] envp) throws IOException + { + String[] a = new String[1]; + a[0] = prog; + return exec (a, envp); + } + + public Process exec (String[] progarray) throws IOException + { + return exec (progarray, null); + } + + public Process exec (String[] progarray, String[] envp) throws IOException + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkExec(progarray[0]); + // FIXME. + return null; + } + + private final static void checkExit (int status) + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkExit(status); + } + + public native void exit (int status); + + public native long freeMemory (); + public native void gc (); + + // Deprecated in 1.1. We implement what the JCL book says. + public InputStream getLocalizedInputStream (InputStream in) + { + return in; + } + + // Deprecated in 1.1. We implement what the JCL book says. + public OutputStream getLocalizedOutputStream (OutputStream out) + { + return out; + } + + public static Runtime getRuntime () + { + return self; + } + + private final void checkLink (String lib) + { + if (lib == null) + throw new NullPointerException (); + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkLink(lib); + } + + public synchronized void load (String pathname) + { + checkLink (pathname); + // FIXME. + throw new UnsatisfiedLinkError ("Runtime.load not implemented"); + } + public synchronized void loadLibrary (String libname) + { + checkLink (libname); + // FIXME. + throw new UnsatisfiedLinkError ("Runtime.loadLibrary not implemented"); + } + + public native void runFinalization (); + + // This method is static in JDK 1.1, but isn't listed as static in + // the books. It is marked as static in the 1.2 docs. + public static void runFinalizersOnExit (boolean run) + { + // The status we pass to the security check is unspecified. + checkExit (0); + self.finalize_on_exit = run; + } + + public native long totalMemory (); + public native void traceInstructions (boolean on); + public native void traceMethodCalls (boolean on); + + // The sole constructor. + private Runtime () + { + finalize_on_exit = false; + } + + // Private data. + private static Runtime self = new Runtime (); + // FIXME: for now this can't be static. If it is, our compiler will + // mark it as local, and it will be inaccessible to natRuntime.cc. + private boolean finalize_on_exit; +} diff --git a/libjava/java/lang/RuntimeException.java b/libjava/java/lang/RuntimeException.java new file mode 100644 index 00000000000..e0d3f5397d3 --- /dev/null +++ b/libjava/java/lang/RuntimeException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class RuntimeException extends Exception +{ + public RuntimeException() + { + super(); + } + + public RuntimeException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/SecurityException.java b/libjava/java/lang/SecurityException.java new file mode 100644 index 00000000000..8a6a94f7f75 --- /dev/null +++ b/libjava/java/lang/SecurityException.java @@ -0,0 +1,31 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class SecurityException extends RuntimeException +{ + public SecurityException() + { + super(); + } + + public SecurityException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/SecurityManager.java b/libjava/java/lang/SecurityManager.java new file mode 100644 index 00000000000..50091f1044e --- /dev/null +++ b/libjava/java/lang/SecurityManager.java @@ -0,0 +1,263 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +// SecurityManager + +package java.lang; + +/** + * @author Anthony Green + * @date October 5, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + */ + +import java.io.*; +import java.net.*; + +public abstract class SecurityManager +{ + protected boolean inCheck = false; + + public void checkAccept (String host, int port) + { + throw new SecurityException(); + } + + public void checkAccess (Thread thrd) + { + throw new SecurityException(); + } + + public void checkAccess (ThreadGroup thrdGroup) + { + throw new SecurityException(); + } + + public void checkAwtEventQueueAccess () + { + throw new SecurityException(); + } + + public void checkConnect (String host, int prt) + { + throw new SecurityException(); + } + + public void checkConnect (String host, int prt, Object ctx) + { + throw new SecurityException(); + } + + public void checkCreateClassLoader () + { + throw new SecurityException(); + } + + public void checkDelete (String fileName) + { + throw new SecurityException(); + } + + public void checkExec (String prog) + { + throw new SecurityException(); + } + + public void checkExit (int stat) + { + throw new SecurityException(); + } + + public void checkLink (String lib) + { + throw new SecurityException(); + } + + public void checkListen (int lport) + { + throw new SecurityException(); + } + + public void checkMemberAccess (Class cl, int mtype) + { + throw new SecurityException(); + } + + public void checkMulticast (InetAddress maddr) + { + throw new SecurityException(); + } + + public void checkMulticast (InetAddress maddr, byte ttl) + { + throw new SecurityException(); + } + + public void checkPackageAccess (String pkg) + { + throw new SecurityException(); + } + + public void checkPackageDefinition (String pkg) + { + throw new SecurityException(); + } + + public void checkPrintJobAccess () + { + throw new SecurityException(); + } + + public void checkPropertiesAccess () + { + throw new SecurityException(); + } + + public void checkPropertyAccess (String prop) + { + throw new SecurityException(); + } + + public void checkPropertyAccess (String prop, String defval) + { + throw new SecurityException(); + } + + public void checkRead (FileDescriptor fd) + { + throw new SecurityException(); + } + + public void checkRead (String fileName) + { + throw new SecurityException(); + } + + public void checkRead (String fileName, Object ctx) + { + throw new SecurityException(); + } + + public void checkSecurityAccess (String action) + { + throw new SecurityException(); + } + + public void checkSetFactory () + { + throw new SecurityException(); + } + + public void checkSystemClipboardAccess () + { + throw new SecurityException(); + } + + public boolean checkTopLevelWindow (Object window) + { + throw new SecurityException(); + } + + public void checkWrite (FileDescriptor fd) + { + throw new SecurityException(); + } + + public void checkWrite (String fileName) + { + throw new SecurityException(); + } + + // Note: this method is deprecated in JDK 1.2 + protected /* native */ int classDepth (String className) + { + Class[] classStack = getClassContext (); + for (int i = 0; i < classStack.length; i++) + if (classStack[i].getName().compareTo(className) == 0) + return i; + + return -1; + } + + // Note: this method is deprecated in JDK 1.2 + protected /* native */ int classLoaderDepth () + { + Class[] classStack = getClassContext (); + for (int i = 0; i < classStack.length; i++) + if (classStack[i].getClassLoader() != null) + return i; + + return -1; + } + + protected /* native */ ClassLoader currentClassLoader () + { + Class[] classStack = getClassContext (); + for (int i = 0; i < classStack.length; i++) + { + ClassLoader loader = classStack[i].getClassLoader(); + if (loader != null) + return loader; + } + + return null; + } + + protected /* native */ Class currentLoadedClass () + { + Class[] classStack = getClassContext (); + for (int i = 0; i < classStack.length; i++) + { + ClassLoader loader = classStack[i].getClassLoader(); + if (loader != null) + return classStack[i]; + } + + return null; + } + + protected /* native */ Class[] getClassContext () + { + return new Class[0]; + } + + // Note: this method is deprecated in JDK 1.2 + public boolean getInCheck () + { + return inCheck; + } + + public Object getSecurityContext () + { + // FIXME: This has yet to be implemented. + return new String(""); + } + + public ThreadGroup getThreadGroup () + { + return Thread.currentThread().getThreadGroup(); + } + + protected boolean inClass (String className) + { + return (classDepth (className) != -1); + } + + protected boolean inClassLoader () + { + return (classLoaderDepth () != -1); + } + + protected SecurityManager () + { + if (System.getSecurityManager () != null) + throw new SecurityException (); + } +} diff --git a/libjava/java/lang/Short.java b/libjava/java/lang/Short.java new file mode 100644 index 00000000000..4a17f2d6ea7 --- /dev/null +++ b/libjava/java/lang/Short.java @@ -0,0 +1,145 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Per Bothner + * @date April 17, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + * Includes JDK 1.2 methods. + */ + +public final class Short extends Number implements Comparable +{ + short value; + + public final static short MIN_VALUE = -32768; + public final static short MAX_VALUE = 32767; + + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public static final Class TYPE = short.class; + + public Short(short value) + { + this.value = value; + } + + public Short(String str) + throws NumberFormatException + { + this.value = parseShort(str, 10); + } + + public byte byteValue() + { + return (byte) value; + } + + public short shortValue() + { + return value; + } + + public int intValue() + { + return value; + } + + public long longValue () + { + return value; + } + + public float floatValue () + { + return (float) value; + } + + public double doubleValue () + { + return (double) value; + } + + public static Short decode(String str) + throws NumberFormatException + { + int i = (Integer.decode(str)).intValue(); + if (i < MIN_VALUE || i > MAX_VALUE) + throw new NumberFormatException(); + return new Short((short) i); + } + + public static short parseShort(String str, int radix) + throws NumberFormatException + { + int i = Integer.parseInt(str, radix); + if (i < MIN_VALUE || i > MAX_VALUE) + throw new NumberFormatException(); + return (short) i; + } + + public static short parseShort(String str) + throws NumberFormatException + { + return parseShort(str, 10); + } + + public static Short valueOf(String str, int radix) + throws NumberFormatException + { + return new Short(parseShort(str, radix)); + } + + public static Short valueOf(String str) + throws NumberFormatException + { + return valueOf(str, 10); + } + + // Added in JDK 1.2 + public int compareTo(Short anotherShort) + { + return this.value - anotherShort.value; + } + + // Added in JDK 1.2 + public int compareTo(Object o) throws ClassCastException + { + if (o instanceof Short) + return this.value - ((Short) o).value; + else + throw new ClassCastException(); + } + + public boolean equals(Object obj) + { + return (obj != null && (obj instanceof Short) + && ((Short) obj).value == value); + } + + // Verified that hashCode is returns plain value (see Short_1 test). + public int hashCode() + { + return value; + } + + public String toString() + { + return Integer.toString((int) value); + } + + public static String toString(short value) + { + return Integer.toString((int) value); + } +} diff --git a/libjava/java/lang/StackOverflowError.java b/libjava/java/lang/StackOverflowError.java new file mode 100644 index 00000000000..ace8b25c1a0 --- /dev/null +++ b/libjava/java/lang/StackOverflowError.java @@ -0,0 +1,34 @@ +// StackOverflowError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class StackOverflowError extends VirtualMachineError +{ + public StackOverflowError () + { + super (); + } + + public StackOverflowError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/String.java b/libjava/java/lang/String.java new file mode 100644 index 00000000000..1321676d0e5 --- /dev/null +++ b/libjava/java/lang/String.java @@ -0,0 +1,286 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; +import java.io.UnsupportedEncodingException; + +/** + * @author Per Bothner + * @date September 4, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Complete to 1.1, but see FIXMEs. Also see testsuite results. + */ + +public final class String +{ + private Object data; + private int boffset; // Note this is a byte offset - don't use in Java code! + private int count; + + public String () + { + init(); + } + + public String (String value) + { + data = value.data; + boffset = value.boffset; + count = value.count; + } + + public String (StringBuffer buffer) + { + init (buffer.value, 0, buffer.count, true); + } + + public String (char[] data) + { + init(data, 0, data.length, false); + } + + public String (char[] data, int offset, int count) + { + init(data, offset, count, false); + } + + public String (byte[] byteArray) + { + this (byteArray, 0, byteArray.length); + } + + public String (byte[] byteArray, int offset, int count) + { + try + { + init (byteArray, offset, count, + System.getProperty("file.encoding", "8859_1")); + } + catch (UnsupportedEncodingException x1) + { + // Maybe the default encoding is bad. + try + { + init (byteArray, offset, count, "8859_1"); + } + catch (UnsupportedEncodingException x2) + { + // We know this can't happen. + } + } + } + + public String (byte[] byteArray, String enc) + throws UnsupportedEncodingException + { + this (byteArray, 0, byteArray.length, enc); + } + + public String (byte[] byteArray, int offset, int count, String enc) + throws UnsupportedEncodingException + { + init (byteArray, offset, count, enc); + } + + public static String copyValueOf(char[] data) + { + return copyValueOf (data, 0, data.length); + } + + public static String copyValueOf(char[] data, int offset, int count) + { + String r = new String (); + r.init(data, offset, count, false); + return r; + } + + /** @deprecated */ + public String (byte[] ascii, int hibyte) + { + init(ascii, hibyte, 0, ascii.length); + } + + /** @deprecated */ + public String (byte[] ascii, int hibyte, int offset, int count) + { + init(ascii, hibyte, offset, count); + } + + public String toString () + { + return this; + } + + public native boolean equals (Object anObject); + + public native int hashCode (); + + public int length () + { + return count; + } + + public native char charAt (int index); + + public native void getChars (int srcBegin, int srcEnd, + char[] dst, int dstBegin); + + public byte[] getBytes () throws UnsupportedEncodingException + { + return getBytes (System.getProperty("file.encoding", "8859_1")); + } + + public native byte[] getBytes (String enc) + throws UnsupportedEncodingException; + + /** @deprecated */ + public native void getBytes (int srcBegin, int srcEnd, + byte[] dst, int dstBegin); + + public native char[] toCharArray (); + + public native boolean equalsIgnoreCase (String anotherString); + + public native int compareTo (String anotherString); + + public native boolean regionMatches (int toffset, + String other, int ooffset, int len); + + public native boolean regionMatches (boolean ignoreCase, int toffset, + String other, int ooffset, int len); + + public boolean startsWith (String prefix) + { + return startsWith (prefix, 0); + } + + public native boolean startsWith (String prefix, int toffset); + + public boolean endsWith (String suffix) + { + return regionMatches (this.count - suffix.count, suffix, 0, suffix.count); + } + + // No such method specified in the doc, including JDK 1.2. + // public boolean endsWith (String suffix, int toffset) + // { + // return regionMatches (toffset, suffix, 0, suffix.count); + // } + + // The Language Specification, and the JDK 1.2 API docs say that + // index and lastIndex take an int, while the Class Libraries + // say they take a char. The former wins ... + + public int indexOf (int ch) + { + return indexOf (ch, 0); + } + + public native int indexOf (int ch, int fromIndex); + + public int indexOf (String str) + { + return indexOf (str, 0); + } + + public native int indexOf (String str, int fromIndex); + + public int lastIndexOf (int ch) + { + return lastIndexOf (ch, count - 1); + } + + public native int lastIndexOf (int ch, int fromIndex); + + public int lastIndexOf (String str) + { + return lastIndexOf (str, count - str.count); + } + + public int lastIndexOf (String str, int fromIndex) + { + if (fromIndex >= count) + fromIndex = count - str.count; + for (;; --fromIndex) + { + if (fromIndex < 0) + return -1; + if (startsWith(str, fromIndex)) + return fromIndex; + } + } + + public String substring (int beginIndex) + { + return substring (beginIndex, count); + } + + public native String substring (int beginIndex, int endIndex); + + public native String concat (String str); + + public native String replace (char oldChar, char newChar); + + public native String toLowerCase (); + + public native String toUpperCase (); + + public native String trim (); + + public static String valueOf (Object obj) + { + return obj == null ? "null" : obj.toString(); + } + + public static String valueOf (char[] data) + { + return valueOf (data, 0, data.length); + } + + public static native String valueOf (char[] data, int offset, int count); + + public static String valueOf (boolean b) + { + return b ? "true" : "false"; + } + + public static native String valueOf (char c); + + public static String valueOf (int i) + { + return Integer.toString(i); + } + + public static String valueOf (long l) + { + return Long.toString(l); + } + + public static String valueOf (float f) + { + return Float.toString(f); + } + + public static String valueOf (double d) + { + return Double.toString(d); + } + + public native String intern (); + + private native void init (); + private native void init (char[] chars, int offset, int count, + boolean dont_copy); + private native void init (byte[] chars, int hibyte, int offset, int count); + private native void init (byte[] chars, int offset, int count, String enc) + throws UnsupportedEncodingException; + private native void unintern (); + private static native void rehash (); +} diff --git a/libjava/java/lang/StringBuffer.java b/libjava/java/lang/StringBuffer.java new file mode 100644 index 00000000000..4127d54787f --- /dev/null +++ b/libjava/java/lang/StringBuffer.java @@ -0,0 +1,270 @@ +// StringBuffer.java - Growable strings. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; +import java.io.Serializable; + +/** + * @author Tom Tromey + * @date October 23, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + */ + +public final class StringBuffer implements Serializable +{ + public StringBuffer append (boolean bool) + { + return append (String.valueOf(bool)); + } + + public synchronized StringBuffer append (char ch) + { + ensureCapacity (count + 1); + value[count++] = ch; + return this; + } + + public StringBuffer append (int inum) + { + return append (String.valueOf(inum)); + } + + public StringBuffer append (long lnum) + { + return append (String.valueOf(lnum)); + } + + public StringBuffer append (float fnum) + { + return append (String.valueOf(fnum)); + } + + public StringBuffer append (double dnum) + { + return append (String.valueOf(dnum)); + } + + public StringBuffer append (Object obj) + { + return append (String.valueOf(obj)); + } + + public synchronized StringBuffer append (String str) + { + if (str == null) + str = "null"; + int len = str.length(); + ensureCapacity (count + len); + str.getChars(0, len, value, count); + count += len; + return this; + } + + public StringBuffer append (char[] data) + { + return append (data, 0, data.length); + } + + public synchronized StringBuffer append (char[] data, int offset, int count) + { + ensureCapacity (this.count + count); + System.arraycopy(data, offset, value, this.count, count); + this.count += count; + return this; + } + + public int capacity () + { + return value.length; + } + + public synchronized char charAt (int index) + { + if (index >= count) + throw new StringIndexOutOfBoundsException (index); + return value[index]; + } + + public synchronized void ensureCapacity (int minimumCapacity) + { + if (shared || minimumCapacity > value.length) + { + minimumCapacity = Math.max(minimumCapacity, value.length*2+2); + char[] nb = new char[minimumCapacity]; + System.arraycopy(value, 0, nb, 0, count); + value = nb; + shared = false; + } + } + + public synchronized void getChars (int srcOffset, int srcEnd, + char[] dst, int dstOffset) + { + if (srcOffset < 0 || srcOffset > srcEnd) + throw new StringIndexOutOfBoundsException (srcOffset); + int todo = srcEnd - srcOffset; + if (srcEnd > count || dstOffset + todo > count) + throw new StringIndexOutOfBoundsException (srcEnd); + System.arraycopy(value, srcOffset, dst, dstOffset, todo); + } + + public StringBuffer insert (int offset, boolean bool) + { + return insert (offset, bool ? "true" : "false"); + } + + public synchronized StringBuffer insert (int offset, char ch) + { + if (offset < 0 || offset > count) + throw new StringIndexOutOfBoundsException (offset); + ensureCapacity (count+1); + System.arraycopy(value, offset, value, offset+1, count-offset); + value[offset] = ch; + count++; + return this; + } + + public StringBuffer insert (int offset, int inum) + { + return insert (offset, String.valueOf(inum)); + } + + public StringBuffer insert (int offset, long lnum) + { + return insert (offset, String.valueOf(lnum)); + } + + public StringBuffer insert (int offset, float fnum) + { + return insert (offset, String.valueOf(fnum)); + } + + public StringBuffer insert (int offset, double dnum) + { + return insert (offset, String.valueOf(dnum)); + } + + public StringBuffer insert (int offset, Object obj) + { + return insert (offset, String.valueOf(obj)); + } + + public synchronized StringBuffer insert (int offset, String str) + { + if (offset < 0 || offset > count) + throw new StringIndexOutOfBoundsException (offset); + // Note that using `null' is from JDK 1.2. + if (str == null) + str = "null"; + int len = str.length(); + ensureCapacity(count+len); + System.arraycopy(value, offset, value, offset+len, count-offset); + str.getChars(0, len, value, offset); + count += len; + return this; + } + + public synchronized StringBuffer insert (int offset, char[] data) + { + if (offset < 0 || offset > count) + throw new StringIndexOutOfBoundsException (offset); + int len = data.length; + ensureCapacity (count+len); + System.arraycopy(value, offset, value, offset+len, count-offset); + System.arraycopy(data, 0, value, offset, len); + count += len; + return this; + } + + public int length () + { + return count; + } + + public synchronized StringBuffer reverse () + { + for (int i = 0; i < count / 2; ++i) + { + char c = value[i]; + value[i] = value[count - i - 1]; + value[count - i - 1] = c; + } + return this; + } + + public synchronized void setCharAt (int index, char ch) + { + if (index < 0 || index >= count) + throw new StringIndexOutOfBoundsException (index); + // Call ensureCapacity to enforce copy-on-write. + ensureCapacity (count); + value[index] = ch; + } + + public synchronized void setLength (int newLength) + { + if (newLength < 0) + throw new StringIndexOutOfBoundsException (newLength); + + ensureCapacity (newLength); + for (int i = count; i < newLength; ++i) + value[i] = '\0'; + count = newLength; + } + + public StringBuffer () + { + this (16); + } + + public StringBuffer (int capacity) + { + count = 0; + value = new char[capacity]; + shared = false; + } + + public StringBuffer (String str) + { + // Note: nowhere does it say that we should handle a null + // argument here. In fact, the JCL implies that we should not. + // But this leads to an asymmetry: `null + ""' will fail, while + // `"" + null' will work. + if (str == null) + str = "null"; + count = str.length(); + // JLS: The initial capacity of the string buffer is 16 plus the + // length of the argument string. + value = new char[count + 16]; + str.getChars(0, count, value, 0); + shared = false; + } + + public String toString () + { + shared = true; + return new String (this); + } + + // The buffer. Note that this has permissions set this way so that + // String can get the value. + char[] value; + + // Index of next available character. Note that this has + // permissions set this way so that String can get the value. + int count; + + // True if we need to copy the buffer before writing to it again. + // FIXME: JDK 1.2 doesn't specify this. The new buffer-growing + // semantics make this less useful in that case, too. + private boolean shared; +} diff --git a/libjava/java/lang/StringIndexOutOfBoundsException.java b/libjava/java/lang/StringIndexOutOfBoundsException.java new file mode 100644 index 00000000000..200acb896f0 --- /dev/null +++ b/libjava/java/lang/StringIndexOutOfBoundsException.java @@ -0,0 +1,37 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class StringIndexOutOfBoundsException extends IndexOutOfBoundsException +{ + public StringIndexOutOfBoundsException() + { + super(); + } + + public StringIndexOutOfBoundsException(int index) + { + this("String index out of range: " + index); + } + + public StringIndexOutOfBoundsException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/System.java b/libjava/java/lang/System.java new file mode 100644 index 00000000000..6f6dee42057 --- /dev/null +++ b/libjava/java/lang/System.java @@ -0,0 +1,166 @@ +// System.java - System-specific info. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.FilterInputStream; +import java.io.InputStream; +import java.io.PrintStream; +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.util.Properties; + +/** + * @author Tom Tromey + * @date August 27, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: 1.1. Some 1.2 methods missing. Properties code not fully + * implemented. + */ + +public final class System +{ + public static native void arraycopy (Object src, int srcOffset, + Object dst, int dstOffset, + int count); + + public static native long currentTimeMillis (); + + public static void exit (int status) + { + Runtime.getRuntime().exit(status); + } + + public static void gc () + { + Runtime.getRuntime().gc(); + } + + // Marked deprecated in 1.1. We implement what the JCL book says. + public static String getenv (String name) + { + throw new Error (); + } + + private static native void init_properties (); + + public static Properties getProperties () + { + if (secman != null) + secman.checkPropertiesAccess(); + init_properties (); + return properties; + } + + public static String getProperty (String property) + { + if (secman != null) + secman.checkPropertyAccess(property); + init_properties (); + return properties.getProperty(property); + } + + public static String getProperty (String property, String defval) + { + if (secman != null) + secman.checkPropertyAccess(property, defval); + init_properties (); + return properties.getProperty(property, defval); + } + + public static SecurityManager getSecurityManager () + { + return secman; + } + + public static native int identityHashCode (Object obj); + + public static void load (String pathname) + { + Runtime.getRuntime().load(pathname); + } + + public static void loadLibrary (String libname) + { + Runtime.getRuntime().loadLibrary(libname); + } + + public static void runFinalization () + { + Runtime.getRuntime().runFinalization(); + } + + // Marked as deprecated in 1.2. + public static void runFinalizersOnExit (boolean run) + { + Runtime.getRuntime().runFinalizersOnExit(run); + } + + private static void checkSetIO () + { + // In 1.1, we are supposed to call checkExec, but the argument is + // not specified. In 1.2, we are supposed to use checkPermission, + // which doesn't exist in 1.1. + if (secman != null) + secman.checkExec(""); + } + + public static native void setErr (PrintStream newErr); + public static native void setIn (InputStream newIn); + public static native void setOut (PrintStream newOut); + + public static void setProperties (Properties props) + { + if (secman != null) + secman.checkPropertiesAccess(); + // We might not have initialized yet. + prop_init = true; + properties = props; + } + + // TODO 1.2. + // public static String setProperty (String key, String value); + + // TODO 1.2. + // public static String mapLibraryName (String libname); + + public static void setSecurityManager (SecurityManager s) + { + if (secman != null) + throw new SecurityException (); + secman = s; + } + + // Public data. + public static final InputStream in = new BufferedInputStream (new FileInputStream (FileDescriptor.in)); + + public static final PrintStream out = new PrintStream (new BufferedOutputStream (new FileOutputStream (FileDescriptor.out)), true); + + public static final PrintStream err = new PrintStream (new BufferedOutputStream (new FileOutputStream (FileDescriptor.err)), true); + + // Don't allow System objects to be made. + private System () + { + } + + // Private data. + private static SecurityManager secman = null; + private static Properties properties = null; + // This boolean is only required for 1.1 and earlier. After 1.1, a + // null properties should always be re-initialized. + private static boolean prop_init = false; +} diff --git a/libjava/java/lang/Thread.java b/libjava/java/lang/Thread.java new file mode 100644 index 00000000000..f21d3a3fb7d --- /dev/null +++ b/libjava/java/lang/Thread.java @@ -0,0 +1,297 @@ +// Thread.java - Thread class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date August 24, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Complete to version 1.1, with caveats + * Known problems: + * No attempt was made to implement suspend/resume + * (this could be done in some cases) + * Various methods which assume a VM are likewise unimplemented + * We do implement stop() even though it is deprecated. + */ + +public class Thread implements Runnable +{ + public final static int MAX_PRIORITY = 10; + public final static int MIN_PRIORITY = 1; + public final static int NORM_PRIORITY = 5; + + public static int activeCount () + { + return currentThread().getThreadGroup().activeCount(); + } + + public void checkAccess () + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkAccess(this); + } + + public native int countStackFrames (); + public static native Thread currentThread (); + public native void destroy (); + public static native void dumpStack (); + + public static int enumerate (Thread[] threads) + { + return currentThread().group.enumerate(threads); + } + + public final String getName () + { + return name; + } + + public final int getPriority () + { + return priority; + } + + public final ThreadGroup getThreadGroup () + { + return group; + } + + public native void interrupt (); + + public static boolean interrupted () + { + return currentThread().isInterrupted(); + } + + // FIXME: it seems to me that this should be synchronized. + public boolean isInterrupted () + { + boolean r = interrupt_flag; + interrupt_flag = false; + return r; + } + + public final boolean isAlive () + { + return alive_flag; + } + + public final boolean isDaemon () + { + return daemon_flag; + } + + public final void join () throws InterruptedException + { + join (0, 0); + } + + public final void join (long timeout) throws InterruptedException + { + join (timeout, 0); + } + + public final native void join (long timeout, int nanos) + throws InterruptedException; + + public final native void resume (); + + // This method exists only to avoid a warning from the C++ compiler. + private static final native void run__ (Object obj); + private native final void finish_ (); + private final void run_ () + { + try + { + run (); + } + catch (Throwable e) + { + // Uncaught exceptions are forwarded to the ThreadGroup. If + // this results in an uncaught exception, that is ignored. + try + { + group.uncaughtException(this, e); + } + catch (Throwable f) + { + // Nothing. + } + } + finish_ (); + } + + public void run () + { + if (runnable != null) + runnable.run(); + } + + public final void setDaemon (boolean status) + { + checkAccess (); + if (isAlive ()) + throw new IllegalThreadStateException (); + daemon_flag = status; + } + + // TODO12: + // public ClassLoader getContextClassLoader() + // { + // } + + // TODO12: + // public void setContextClassLoader(ClassLoader cl) + // { + // } + + public final void setName (String n) + { + checkAccess (); + // The Class Libraries book says ``threadName cannot be null''. I + // take this to mean NullPointerException. + if (n == null) + throw new NullPointerException (); + name = n; + } + + public final native void setPriority (int newPriority); + + public static void sleep (long timeout) throws InterruptedException + { + sleep (timeout, 0); + } + + public static native void sleep (long timeout, int nanos) + throws InterruptedException; + public synchronized native void start (); + + public final void stop () + { + stop (new ThreadDeath ()); + } + + public final synchronized native void stop (Throwable e); + public final native void suspend (); + + private final native void initialize_native (); + + private final synchronized static String gen_name () + { + String n; + n = "Thread-" + nextThreadNumber; + ++nextThreadNumber; + return n; + } + + public Thread (ThreadGroup g, Runnable r, String n) + { + // Note that CURRENT can be null when we are creating the very + // first thread. That's why we check it below. + Thread current = currentThread (); + + if (g != null) + { + // If CURRENT is null, then we are creating the first thread. + // In this case we don't do the security check. + if (current != null) + g.checkAccess(); + } + else + g = current.getThreadGroup(); + + // The Class Libraries book says ``threadName cannot be null''. I + // take this to mean NullPointerException. + if (n == null) + throw new NullPointerException (); + + name = n; + group = g; + g.add(this); + runnable = r; + + data = null; + interrupt_flag = false; + alive_flag = false; + if (current != null) + { + daemon_flag = current.isDaemon(); + priority = current.getPriority(); + } + else + { + daemon_flag = false; + priority = NORM_PRIORITY; + } + + initialize_native (); + } + + public Thread () + { + this (null, null, gen_name ()); + } + + public Thread (Runnable r) + { + this (null, r, gen_name ()); + } + + public Thread (String n) + { + this (null, null, n); + } + + public Thread (ThreadGroup g, Runnable r) + { + this (g, r, gen_name ()); + } + + public Thread (ThreadGroup g, String n) + { + this (g, null, n); + } + + public Thread (Runnable r, String n) + { + this (null, r, n); + } + + public String toString () + { + return "Thread[" + name + "," + priority + "," + group.getName() + "]"; + } + + public static native void yield (); + + // Private data. + private ThreadGroup group; + private String name; + private Runnable runnable; + private int priority; + private boolean daemon_flag; + private boolean interrupt_flag; + private boolean alive_flag; + + // This is a bit odd. We need a way to represent some data that is + // manipulated only by the native side of this class. We represent + // it as a Java object reference. However, it is not actually a + // Java object. + private Object data; + + // Next thread number to assign. + private static int nextThreadNumber = 0; +} diff --git a/libjava/java/lang/ThreadDeath.java b/libjava/java/lang/ThreadDeath.java new file mode 100644 index 00000000000..caffc936d2e --- /dev/null +++ b/libjava/java/lang/ThreadDeath.java @@ -0,0 +1,35 @@ +// ThreadDeath.java - Special exception registering Thread death. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date August 26, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Complete to version 1.1 + */ + +public class ThreadDeath extends Error +{ + public ThreadDeath () + { + super (); + } + + public ThreadDeath (String message) + { + super (message); + } +} diff --git a/libjava/java/lang/ThreadGroup.java b/libjava/java/lang/ThreadGroup.java new file mode 100644 index 00000000000..1aa1a9a3bed --- /dev/null +++ b/libjava/java/lang/ThreadGroup.java @@ -0,0 +1,406 @@ +// ThreadGroup.java - ThreadGroup class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +import java.util.Enumeration; +import java.util.Vector; + +/** + * @author Tom Tromey + * @date August 25, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Complete for 1.1. Parts from the JDK 1.0 spec only are + * not implemented. Parts of the 1.2 spec are also not implemented. + */ + +public class ThreadGroup +{ + public int activeCount () + { + int ac = threads.size(); + Enumeration e = groups.elements(); + while (e.hasMoreElements()) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + ac += g.activeCount(); + } + return ac; + } + + public int activeGroupCount () + { + int ac = groups.size(); + Enumeration e = groups.elements(); + while (e.hasMoreElements()) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + ac += g.activeGroupCount(); + } + return ac; + } + + // Deprecated in 1.2. + public boolean allowThreadSuspension (boolean allow) + { + // There is no way for a Java program to determine whether this + // has any effect whatsoever. We don't need it. + return true; + } + + public final void checkAccess () + { + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkAccess(this); + } + + // This is called to remove a ThreadGroup from our internal list. + private final void remove (ThreadGroup g) + { + groups.removeElement(g); + if (daemon_flag && groups.size() == 0 && threads.size() == 0) + { + // We inline destroy to avoid the access check. + destroyed_flag = true; + if (parent != null) + parent.remove(this); + } + } + + // This is called by the Thread code to remove a Thread from our + // internal list. FIXME: currently, it isn't called at all. There + // doesn't appear to be any way to remove a Thread from a + // ThreadGroup (except the unimplemented destroy method). + final void remove (Thread t) + { + threads.removeElement(t); + if (daemon_flag && groups.size() == 0 && threads.size() == 0) + { + // We inline destroy to avoid the access check. + destroyed_flag = true; + if (parent != null) + parent.remove(this); + } + } + + // This is called by the Thread code to add a Thread to our internal + // list. + final void add (Thread t) + { + if (destroyed_flag) + throw new IllegalThreadStateException (); + + threads.addElement(t); + } + + // This is a helper that is used to implement the destroy method. + private final boolean canDestroy () + { + if (! threads.isEmpty()) + return false; + Enumeration e = groups.elements(); + while (e.hasMoreElements()) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + if (! g.canDestroy()) + return false; + } + return true; + } + + public final void destroy () + { + checkAccess (); + if (! canDestroy ()) + throw new IllegalThreadStateException (); + destroyed_flag = true; + if (parent != null) + parent.remove(this); + } + + // This actually implements enumerate. + private final int enumerate (Thread[] ts, int next_index, boolean recurse) + { + Enumeration e = threads.elements(); + while (e.hasMoreElements() && next_index < ts.length) + ts[next_index++] = (Thread) e.nextElement(); + if (recurse && next_index != ts.length) + { + e = groups.elements(); + while (e.hasMoreElements() && next_index < ts.length) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + next_index = g.enumerate(ts, next_index, true); + } + } + return next_index; + } + + public int enumerate (Thread[] ts) + { + return enumerate (ts, 0, true); + } + + public int enumerate (Thread[] ts, boolean recurse) + { + return enumerate (ts, 0, recurse); + } + + // This actually implements enumerate. + private final int enumerate (ThreadGroup[] ts, int next_index, + boolean recurse) + { + Enumeration e = groups.elements(); + while (e.hasMoreElements() && next_index < ts.length) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + ts[next_index++] = g; + if (recurse && next_index != ts.length) + next_index = g.enumerate(ts, next_index, true); + } + return next_index; + } + + public int enumerate (ThreadGroup[] gs) + { + return enumerate (gs, 0, true); + } + + public int enumerate (ThreadGroup[] gs, boolean recurse) + { + return enumerate (gs, 0, recurse); + } + + public final int getMaxPriority () + { + return maxpri; + } + + public final String getName () + { + return name; + } + + public final ThreadGroup getParent () + { + return parent; + } + + // JDK 1.2. + // public void interrupt (); + + public final boolean isDaemon () + { + return daemon_flag; + } + + public synchronized boolean isDestroyed () + { + return destroyed_flag; + } + + private final void list (String indentation) + { + System.out.print(indentation); + System.out.println(toString ()); + String sub = indentation + " "; + Enumeration e = threads.elements(); + while (e.hasMoreElements()) + { + Thread t = (Thread) e.nextElement(); + System.out.print(sub); + System.out.println(t.toString()); + } + e = groups.elements(); + while (e.hasMoreElements()) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + g.list(sub); + } + } + + public void list () + { + list (""); + } + + public final boolean parentOf (ThreadGroup g) + { + while (g != null) + { + if (this == g) + return true; + g = g.parent; + } + return false; + } + + // Deprecated in 1.2. + public final void resume () + { + checkAccess (); + Enumeration e = threads.elements(); + while (e.hasMoreElements()) + { + Thread t = (Thread) e.nextElement(); + t.resume(); + } + e = groups.elements(); + while (e.hasMoreElements()) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + g.resume(); + } + } + + public final void setDaemon (boolean daemon) + { + checkAccess (); + daemon_flag = daemon; + // FIXME: the docs don't say you are supposed to do this. But + // they don't say you aren't, either. + if (groups.size() == 0 && threads.size() == 0) + destroy (); + } + + public final void setMaxPriority (int pri) + { + checkAccess (); + + // FIXME: JDK 1.2 behaviour is different: if the newMaxPriority + // argument is < MIN_PRIORITY or > MAX_PRIORITY an + // IllegalArgumentException should be thrown. + if (pri >= Thread.MIN_PRIORITY && pri <= maxpri) + { + maxpri = pri; + + Enumeration e = groups.elements(); + while (e.hasMoreElements()) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + g.setMaxPriority (maxpri); + } + } + } + + // Deprecated in 1.2. + public final void stop () + { + checkAccess (); + Enumeration e = threads.elements(); + while (e.hasMoreElements()) + { + Thread t = (Thread) e.nextElement(); + t.stop(); + } + e = groups.elements(); + while (e.hasMoreElements()) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + g.stop(); + } + } + + // Deprecated in 1.2. + public final void suspend () + { + checkAccess (); + Enumeration e = threads.elements(); + while (e.hasMoreElements()) + { + Thread t = (Thread) e.nextElement(); + t.suspend(); + } + e = groups.elements(); + while (e.hasMoreElements()) + { + ThreadGroup g = (ThreadGroup) e.nextElement(); + g.suspend(); + } + } + + // This constructor appears in the Class Libraries book but in + // neither the Language Spec nor the 1.2 docs. + public ThreadGroup () + { + this (Thread.currentThread().getThreadGroup(), null); + } + + public ThreadGroup (String n) + { + this (Thread.currentThread().getThreadGroup(), n); + } + + public ThreadGroup (ThreadGroup p, String n) + { + checkAccess (); + if (p == null) + throw new NullPointerException (); + if (p.destroyed_flag) + throw new IllegalArgumentException (); + + parent = p; + name = n; + maxpri = p.maxpri; + threads = new Vector (); + groups = new Vector (); + daemon_flag = p.daemon_flag; + destroyed_flag = false; + p.groups.addElement(this); + } + + // This is the constructor that is used when creating the very first + // ThreadGroup. We have an arbitrary argument here just to + // differentiate this constructor from the others. + private ThreadGroup (int dummy) + { + parent = null; + name = "main"; + maxpri = Thread.MAX_PRIORITY; + threads = new Vector (); + groups = new Vector (); + daemon_flag = false; + destroyed_flag = false; + } + + public String toString () + { + // Language Spec and Class Libraries book disagree a bit here. We + // follow the Spec, but add "ThreadGroup" per the book. We + // include "java.lang" based on the list() example in the Class + // Libraries book. + return "java.lang.ThreadGroup[name=" + name + ",maxpri=" + maxpri + "]"; + } + + public void uncaughtException (Thread thread, Throwable e) + { + // FIXME: in 1.2, this has different semantics. In particular if + // this group has a parent, the exception is passed upwards and + // not processed locally. + if (! (e instanceof ThreadDeath)) + { + e.printStackTrace(); + } + } + + // Private data. + private ThreadGroup parent; + private String name; + private int maxpri; + private Vector threads; + private Vector groups; + private boolean daemon_flag; + private boolean destroyed_flag; +} diff --git a/libjava/java/lang/Throwable.java b/libjava/java/lang/Throwable.java new file mode 100644 index 00000000000..5ae39ae2594 --- /dev/null +++ b/libjava/java/lang/Throwable.java @@ -0,0 +1,80 @@ +// Throwable.java - Superclass for all exceptions. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.io.Serializable; + +/** + * @author Tom Tromey + * @date October 30, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Sufficient for compiled code, but methods applicable to + * bytecode not implemented. JDK 1.1. + */ + +public class Throwable implements Serializable +{ + public Throwable fillInStackTrace () + { + return this; + } + + public String getLocalizedMessage () + { + return getMessage (); + } + + public String getMessage () + { + return detailMessage; + } + + public void printStackTrace () + { + printStackTrace (System.err); + } + + public void printStackTrace (PrintStream s) + { + // No stack trace, but we can still print this object. + s.println(toString ()); + } + + public void printStackTrace (PrintWriter wr) + { + // No stack trace, but we can still print this object. + wr.println(toString ()); + } + + public Throwable () + { + detailMessage = null; + } + + public Throwable (String message) + { + detailMessage = message; + } + + public String toString () + { + return ((detailMessage == null) + ? getClass().getName() + : getClass().getName() + ": " + getMessage ()); + } + + // Name of this field comes from serialization spec. + private String detailMessage; +} diff --git a/libjava/java/lang/UnknownError.java b/libjava/java/lang/UnknownError.java new file mode 100644 index 00000000000..edf050c77ec --- /dev/null +++ b/libjava/java/lang/UnknownError.java @@ -0,0 +1,34 @@ +// UnknownError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class UnknownError extends VirtualMachineError +{ + public UnknownError () + { + super (); + } + + public UnknownError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/UnsatisfiedLinkError.java b/libjava/java/lang/UnsatisfiedLinkError.java new file mode 100644 index 00000000000..63930f5555f --- /dev/null +++ b/libjava/java/lang/UnsatisfiedLinkError.java @@ -0,0 +1,34 @@ +// UnsatisfiedLinkError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class UnsatisfiedLinkError extends LinkageError +{ + public UnsatisfiedLinkError () + { + super (); + } + + public UnsatisfiedLinkError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/UnsupportedOperationException.java b/libjava/java/lang/UnsupportedOperationException.java new file mode 100644 index 00000000000..d2bee88622a --- /dev/null +++ b/libjava/java/lang/UnsupportedOperationException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Warren Levy + * @date September 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class UnsupportedOperationException extends RuntimeException +{ + public UnsupportedOperationException() + { + super(); + } + + public UnsupportedOperationException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/lang/VerifyError.java b/libjava/java/lang/VerifyError.java new file mode 100644 index 00000000000..69d6a69baf5 --- /dev/null +++ b/libjava/java/lang/VerifyError.java @@ -0,0 +1,34 @@ +// VerifyError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class VerifyError extends LinkageError +{ + public VerifyError () + { + super (); + } + + public VerifyError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/VirtualMachineError.java b/libjava/java/lang/VirtualMachineError.java new file mode 100644 index 00000000000..dcc907c5d03 --- /dev/null +++ b/libjava/java/lang/VirtualMachineError.java @@ -0,0 +1,34 @@ +// VirtualMachineError.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public abstract class VirtualMachineError extends Error +{ + public VirtualMachineError () + { + super (); + } + + public VirtualMachineError (String msg) + { + super (msg); + } +} diff --git a/libjava/java/lang/Void.java b/libjava/java/lang/Void.java new file mode 100644 index 00000000000..5390552a622 --- /dev/null +++ b/libjava/java/lang/Void.java @@ -0,0 +1,30 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang; + +/** + * @author Per Bothner + * @date April 18, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Complete. + */ + +public final class Void +{ + // This initialization is seemingly circular, but it is accepted + // by javac, and is handled specially by gcc. + public final static Class TYPE = void.class; + + // Don't allow Void objects to be made. + private Void () + { + } +} diff --git a/libjava/java/lang/dtoa.c b/libjava/java/lang/dtoa.c new file mode 100644 index 00000000000..fae45c5aeb4 --- /dev/null +++ b/libjava/java/lang/dtoa.c @@ -0,0 +1,906 @@ +/**************************************************************** + * + * The author of this software is David M. Gay. + * + * Copyright (c) 1991 by AT&T. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose without fee is hereby granted, provided that this entire notice + * is included in all copies of any software which is or includes a copy + * or modification of this software and in all copies of the supporting + * documentation for such software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY + * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. + * + ***************************************************************/ + +/* Please send bug reports to + David M. Gay + AT&T Bell Laboratories, Room 2C-463 + 600 Mountain Avenue + Murray Hill, NJ 07974-2070 + U.S.A. + dmg@research.att.com or research!dmg + */ + +#include "mprec.h" + +static int +_DEFUN (quorem, + (b, S), + _Jv_Bigint * b _AND _Jv_Bigint * S) +{ + int n; + long borrow, y; + unsigned long carry, q, ys; + unsigned long *bx, *bxe, *sx, *sxe; +#ifdef Pack_32 + long z; + unsigned long si, zs; +#endif + + n = S->_wds; +#ifdef DEBUG + /*debug*/ if (b->_wds > n) + /*debug*/ Bug ("oversize b in quorem"); +#endif + if (b->_wds < n) + return 0; + sx = S->_x; + sxe = sx + --n; + bx = b->_x; + bxe = bx + n; + q = *bxe / (*sxe + 1); /* ensure q <= true quotient */ +#ifdef DEBUG + /*debug*/ if (q > 9) + /*debug*/ Bug ("oversized quotient in quorem"); +#endif + if (q) + { + borrow = 0; + carry = 0; + do + { +#ifdef Pack_32 + si = *sx++; + ys = (si & 0xffff) * q + carry; + zs = (si >> 16) * q + (ys >> 16); + carry = zs >> 16; + y = (*bx & 0xffff) - (ys & 0xffff) + borrow; + borrow = y >> 16; + Sign_Extend (borrow, y); + z = (*bx >> 16) - (zs & 0xffff) + borrow; + borrow = z >> 16; + Sign_Extend (borrow, z); + Storeinc (bx, z, y); +#else + ys = *sx++ * q + carry; + carry = ys >> 16; + y = *bx - (ys & 0xffff) + borrow; + borrow = y >> 16; + Sign_Extend (borrow, y); + *bx++ = y & 0xffff; +#endif + } + while (sx <= sxe); + if (!*bxe) + { + bx = b->_x; + while (--bxe > bx && !*bxe) + --n; + b->_wds = n; + } + } + if (cmp (b, S) >= 0) + { + q++; + borrow = 0; + carry = 0; + bx = b->_x; + sx = S->_x; + do + { +#ifdef Pack_32 + si = *sx++; + ys = (si & 0xffff) + carry; + zs = (si >> 16) + (ys >> 16); + carry = zs >> 16; + y = (*bx & 0xffff) - (ys & 0xffff) + borrow; + borrow = y >> 16; + Sign_Extend (borrow, y); + z = (*bx >> 16) - (zs & 0xffff) + borrow; + borrow = z >> 16; + Sign_Extend (borrow, z); + Storeinc (bx, z, y); +#else + ys = *sx++ + carry; + carry = ys >> 16; + y = *bx - (ys & 0xffff) + borrow; + borrow = y >> 16; + Sign_Extend (borrow, y); + *bx++ = y & 0xffff; +#endif + } + while (sx <= sxe); + bx = b->_x; + bxe = bx + n; + if (!*bxe) + { + while (--bxe > bx && !*bxe) + --n; + b->_wds = n; + } + } + return q; +} + +#ifdef DEBUG +#include + +void +print (_Jv_Bigint * b) +{ + int i, wds; + unsigned long *x, y; + wds = b->_wds; + x = b->_x+wds; + i = 0; + do + { + x--; + fprintf (stderr, "%08x", *x); + } + while (++i < wds); + fprintf (stderr, "\n"); +} +#endif + +/* dtoa for IEEE arithmetic (dmg): convert double to ASCII string. + * + * Inspired by "How to Print Floating-Point Numbers Accurately" by + * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 92-101]. + * + * Modifications: + * 1. Rather than iterating, we use a simple numeric overestimate + * to determine k = floor(log10(d)). We scale relevant + * quantities using O(log2(k)) rather than O(k) multiplications. + * 2. For some modes > 2 (corresponding to ecvt and fcvt), we don't + * try to generate digits strictly left to right. Instead, we + * compute with fewer bits and propagate the carry if necessary + * when rounding the final digit up. This is often faster. + * 3. Under the assumption that input will be rounded nearest, + * mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22. + * That is, we allow equality in stopping tests when the + * round-nearest rule will give the same floating-point value + * as would satisfaction of the stopping test with strict + * inequality. + * 4. We remove common factors of powers of 2 from relevant + * quantities. + * 5. When converting floating-point integers less than 1e16, + * we use floating-point arithmetic rather than resorting + * to multiple-precision integers. + * 6. When asked to produce fewer than 15 digits, we first try + * to get by with floating-point arithmetic; we resort to + * multiple-precision integer arithmetic only if we cannot + * guarantee that the floating-point calculation has given + * the correctly rounded result. For k requested digits and + * "uniformly" distributed input, the probability is + * something like 10^(k-15) that we must resort to the long + * calculation. + */ + + +char * +_DEFUN (_dtoa_r, + (ptr, _d, mode, ndigits, decpt, sign, rve, float_type), + struct _Jv_reent *ptr _AND + double _d _AND + int mode _AND + int ndigits _AND + int *decpt _AND + int *sign _AND + char **rve _AND + int float_type) +{ + /* + float_type == 0 for double precision, 1 for float. + + Arguments ndigits, decpt, sign are similar to those + of ecvt and fcvt; trailing zeros are suppressed from + the returned string. If not null, *rve is set to point + to the end of the return value. If d is +-Infinity or NaN, + then *decpt is set to 9999. + + mode: + 0 ==> shortest string that yields d when read in + and rounded to nearest. + 1 ==> like 0, but with Steele & White stopping rule; + e.g. with IEEE P754 arithmetic , mode 0 gives + 1e23 whereas mode 1 gives 9.999999999999999e22. + 2 ==> max(1,ndigits) significant digits. This gives a + return value similar to that of ecvt, except + that trailing zeros are suppressed. + 3 ==> through ndigits past the decimal point. This + gives a return value similar to that from fcvt, + except that trailing zeros are suppressed, and + ndigits can be negative. + 4-9 should give the same return values as 2-3, i.e., + 4 <= mode <= 9 ==> same return as mode + 2 + (mode & 1). These modes are mainly for + debugging; often they run slower but sometimes + faster than modes 2-3. + 4,5,8,9 ==> left-to-right digit generation. + 6-9 ==> don't try fast floating-point estimate + (if applicable). + + > 16 ==> Floating-point arg is treated as single precision. + + Values of mode other than 0-9 are treated as mode 0. + + Sufficient space is allocated to the return value + to hold the suppressed trailing zeros. + */ + + int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1, j, j1, k, k0, + k_check, leftright, m2, m5, s2, s5, spec_case, try_quick; + union double_union d, d2, eps; + long L; +#ifndef Sudden_Underflow + int denorm; + unsigned long x; +#endif + _Jv_Bigint *b, *b1, *delta, *mlo, *mhi, *S; + double ds; + char *s, *s0; + + d.d = _d; + + if (ptr->_result) + { + ptr->_result->_k = ptr->_result_k; + ptr->_result->_maxwds = 1 << ptr->_result_k; + Bfree (ptr, ptr->_result); + ptr->_result = 0; + } + + if (word0 (d) & Sign_bit) + { + /* set sign for everything, including 0's and NaNs */ + *sign = 1; + word0 (d) &= ~Sign_bit; /* clear sign bit */ + } + else + *sign = 0; + +#if defined(IEEE_Arith) + defined(VAX) +#ifdef IEEE_Arith + if ((word0 (d) & Exp_mask) == Exp_mask) +#else + if (word0 (d) == 0x8000) +#endif + { + /* Infinity or NaN */ + *decpt = 9999; + s = +#ifdef IEEE_Arith + !word1 (d) && !(word0 (d) & 0xfffff) ? "Infinity" : +#endif + "NaN"; + if (rve) + *rve = +#ifdef IEEE_Arith + s[3] ? s + 8 : +#endif + s + 3; + return s; + } +#endif +#ifdef IBM + d.d += 0; /* normalize */ +#endif + if (!d.d) + { + *decpt = 1; + s = "0"; + if (rve) + *rve = s + 1; + return s; + } + + b = d2b (ptr, d.d, &be, &bbits); +#ifdef Sudden_Underflow + i = (int) (word0 (d) >> Exp_shift1 & (Exp_mask >> Exp_shift1)); +#else + if ((i = (int) (word0 (d) >> Exp_shift1 & (Exp_mask >> Exp_shift1)))) + { +#endif + d2.d = d.d; + word0 (d2) &= Frac_mask1; + word0 (d2) |= Exp_11; +#ifdef IBM + if (j = 11 - hi0bits (word0 (d2) & Frac_mask)) + d2.d /= 1 << j; +#endif + + /* log(x) ~=~ log(1.5) + (x-1.5)/1.5 + * log10(x) = log(x) / log(10) + * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10)) + * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2) + * + * This suggests computing an approximation k to log10(d) by + * + * k = (i - Bias)*0.301029995663981 + * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 ); + * + * We want k to be too large rather than too small. + * The error in the first-order Taylor series approximation + * is in our favor, so we just round up the constant enough + * to compensate for any error in the multiplication of + * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077, + * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14, + * adding 1e-13 to the constant term more than suffices. + * Hence we adjust the constant term to 0.1760912590558. + * (We could get a more accurate k by invoking log10, + * but this is probably not worthwhile.) + */ + + i -= Bias; +#ifdef IBM + i <<= 2; + i += j; +#endif +#ifndef Sudden_Underflow + denorm = 0; + } + else + { + /* d is denormalized */ + + i = bbits + be + (Bias + (P - 1) - 1); + x = i > 32 ? word0 (d) << (64 - i) | word1 (d) >> (i - 32) + : word1 (d) << (32 - i); + d2.d = x; + word0 (d2) -= 31 * Exp_msk1; /* adjust exponent */ + i -= (Bias + (P - 1) - 1) + 1; + denorm = 1; + } +#endif + ds = (d2.d - 1.5) * 0.289529654602168 + 0.1760912590558 + i * 0.301029995663981; + k = (int) ds; + if (ds < 0. && ds != k) + k--; /* want k = floor(ds) */ + k_check = 1; + if (k >= 0 && k <= Ten_pmax) + { + if (d.d < tens[k]) + k--; + k_check = 0; + } + j = bbits - i - 1; + if (j >= 0) + { + b2 = 0; + s2 = j; + } + else + { + b2 = -j; + s2 = 0; + } + if (k >= 0) + { + b5 = 0; + s5 = k; + s2 += k; + } + else + { + b2 -= k; + b5 = -k; + s5 = 0; + } + if (mode < 0 || mode > 9) + mode = 0; + try_quick = 1; + if (mode > 5) + { + mode -= 4; + try_quick = 0; + } + leftright = 1; + switch (mode) + { + case 0: + case 1: + ilim = ilim1 = -1; + i = 18; + ndigits = 0; + break; + case 2: + leftright = 0; + /* no break */ + case 4: + if (ndigits <= 0) + ndigits = 1; + ilim = ilim1 = i = ndigits; + break; + case 3: + leftright = 0; + /* no break */ + case 5: + i = ndigits + k + 1; + ilim = i; + ilim1 = i - 1; + if (i <= 0) + i = 1; + } + j = sizeof (unsigned long); + for (ptr->_result_k = 0; (int) (sizeof (_Jv_Bigint) - sizeof (unsigned long)) + j <= i; + j <<= 1) + ptr->_result_k++; + ptr->_result = Balloc (ptr, ptr->_result_k); + s = s0 = (char *) ptr->_result; + + if (ilim >= 0 && ilim <= Quick_max && try_quick) + { + /* Try to get by with floating-point arithmetic. */ + + i = 0; + d2.d = d.d; + k0 = k; + ilim0 = ilim; + ieps = 2; /* conservative */ + if (k > 0) + { + ds = tens[k & 0xf]; + j = k >> 4; + if (j & Bletch) + { + /* prevent overflows */ + j &= Bletch - 1; + d.d /= bigtens[n_bigtens - 1]; + ieps++; + } + for (; j; j >>= 1, i++) + if (j & 1) + { + ieps++; + ds *= bigtens[i]; + } + d.d /= ds; + } + else if ((j1 = -k)) + { + d.d *= tens[j1 & 0xf]; + for (j = j1 >> 4; j; j >>= 1, i++) + if (j & 1) + { + ieps++; + d.d *= bigtens[i]; + } + } + if (k_check && d.d < 1. && ilim > 0) + { + if (ilim1 <= 0) + goto fast_failed; + ilim = ilim1; + k--; + d.d *= 10.; + ieps++; + } + eps.d = ieps * d.d + 7.; + word0 (eps) -= (P - 1) * Exp_msk1; + if (ilim == 0) + { + S = mhi = 0; + d.d -= 5.; + if (d.d > eps.d) + goto one_digit; + if (d.d < -eps.d) + goto no_digits; + goto fast_failed; + } +#ifndef No_leftright + if (leftright) + { + /* Use Steele & White method of only + * generating digits needed. + */ + eps.d = 0.5 / tens[ilim - 1] - eps.d; + for (i = 0;;) + { + L = d.d; + d.d -= L; + *s++ = '0' + (int) L; + if (d.d < eps.d) + goto ret1; + if (1. - d.d < eps.d) + goto bump_up; + if (++i >= ilim) + break; + eps.d *= 10.; + d.d *= 10.; + } + } + else + { +#endif + /* Generate ilim digits, then fix them up. */ + eps.d *= tens[ilim - 1]; + for (i = 1;; i++, d.d *= 10.) + { + L = d.d; + d.d -= L; + *s++ = '0' + (int) L; + if (i == ilim) + { + if (d.d > 0.5 + eps.d) + goto bump_up; + else if (d.d < 0.5 - eps.d) + { + while (*--s == '0'); + s++; + goto ret1; + } + break; + } + } +#ifndef No_leftright + } +#endif + fast_failed: + s = s0; + d.d = d2.d; + k = k0; + ilim = ilim0; + } + + /* Do we have a "small" integer? */ + + if (be >= 0 && k <= Int_max) + { + /* Yes. */ + ds = tens[k]; + if (ndigits < 0 && ilim <= 0) + { + S = mhi = 0; + if (ilim < 0 || d.d <= 5 * ds) + goto no_digits; + goto one_digit; + } + for (i = 1;; i++) + { + L = d.d / ds; + d.d -= L * ds; +#ifdef Check_FLT_ROUNDS + /* If FLT_ROUNDS == 2, L will usually be high by 1 */ + if (d.d < 0) + { + L--; + d.d += ds; + } +#endif + *s++ = '0' + (int) L; + if (i == ilim) + { + d.d += d.d; + if (d.d > ds || (d.d == ds && L & 1)) + { + bump_up: + while (*--s == '9') + if (s == s0) + { + k++; + *s = '0'; + break; + } + ++*s++; + } + break; + } + if (!(d.d *= 10.)) + break; + } + goto ret1; + } + + m2 = b2; + m5 = b5; + mhi = mlo = 0; + if (leftright) + { + if (mode < 2) + { + i = +#ifndef Sudden_Underflow + denorm ? be + (Bias + (P - 1) - 1 + 1) : +#endif +#ifdef IBM + 1 + 4 * P - 3 - bbits + ((bbits + be - 1) & 3); +#else + 1 + P - bbits; +#endif + } + else + { + j = ilim - 1; + if (m5 >= j) + m5 -= j; + else + { + s5 += j -= m5; + b5 += j; + m5 = 0; + } + if ((i = ilim) < 0) + { + m2 -= i; + i = 0; + } + } + b2 += i; + s2 += i; + mhi = i2b (ptr, 1); + } + if (m2 > 0 && s2 > 0) + { + i = m2 < s2 ? m2 : s2; + b2 -= i; + m2 -= i; + s2 -= i; + } + if (b5 > 0) + { + if (leftright) + { + if (m5 > 0) + { + mhi = pow5mult (ptr, mhi, m5); + b1 = mult (ptr, mhi, b); + Bfree (ptr, b); + b = b1; + } + if ((j = b5 - m5)) + b = pow5mult (ptr, b, j); + } + else + b = pow5mult (ptr, b, b5); + } + S = i2b (ptr, 1); + if (s5 > 0) + S = pow5mult (ptr, S, s5); + + /* Check for special case that d is a normalized power of 2. */ + + if (mode < 2) + { + if (!word1 (d) && !(word0 (d) & Bndry_mask) +#ifndef Sudden_Underflow + && word0 (d) & Exp_mask +#endif + ) + { + /* The special case */ + b2 += Log2P; + s2 += Log2P; + spec_case = 1; + } + else + spec_case = 0; + } + + /* Arrange for convenient computation of quotients: + * shift left if necessary so divisor has 4 leading 0 bits. + * + * Perhaps we should just compute leading 28 bits of S once + * and for all and pass them and a shift to quorem, so it + * can do shifts and ors to compute the numerator for q. + */ + +#ifdef Pack_32 + if ((i = ((s5 ? 32 - hi0bits (S->_x[S->_wds - 1]) : 1) + s2) & 0x1f)) + i = 32 - i; +#else + if ((i = ((s5 ? 32 - hi0bits (S->_x[S->_wds - 1]) : 1) + s2) & 0xf)) + i = 16 - i; +#endif + if (i > 4) + { + i -= 4; + b2 += i; + m2 += i; + s2 += i; + } + else if (i < 4) + { + i += 28; + b2 += i; + m2 += i; + s2 += i; + } + if (b2 > 0) + b = lshift (ptr, b, b2); + if (s2 > 0) + S = lshift (ptr, S, s2); + if (k_check) + { + if (cmp (b, S) < 0) + { + k--; + b = multadd (ptr, b, 10, 0); /* we botched the k estimate */ + if (leftright) + mhi = multadd (ptr, mhi, 10, 0); + ilim = ilim1; + } + } + if (ilim <= 0 && mode > 2) + { + if (ilim < 0 || cmp (b, S = multadd (ptr, S, 5, 0)) <= 0) + { + /* no digits, fcvt style */ + no_digits: + k = -1 - ndigits; + goto ret; + } + one_digit: + *s++ = '1'; + k++; + goto ret; + } + if (leftright) + { + if (m2 > 0) + mhi = lshift (ptr, mhi, m2); + + /* Single precision case, */ + if (float_type) + mhi = lshift (ptr, mhi, 29); + + /* Compute mlo -- check for special case + * that d is a normalized power of 2. + */ + + mlo = mhi; + if (spec_case) + { + mhi = Balloc (ptr, mhi->_k); + Bcopy (mhi, mlo); + mhi = lshift (ptr, mhi, Log2P); + } + + for (i = 1;; i++) + { + dig = quorem (b, S) + '0'; + /* Do we yet have the shortest decimal string + * that will round to d? + */ + j = cmp (b, mlo); + delta = diff (ptr, S, mhi); + j1 = delta->_sign ? 1 : cmp (b, delta); + Bfree (ptr, delta); +#ifndef ROUND_BIASED + if (j1 == 0 && !mode && !(word1 (d) & 1)) + { + if (dig == '9') + goto round_9_up; + if (j > 0) + dig++; + *s++ = dig; + goto ret; + } +#endif + if (j < 0 || (j == 0 && !mode +#ifndef ROUND_BIASED + && !(word1 (d) & 1) +#endif + )) + { + if (j1 > 0) + { + b = lshift (ptr, b, 1); + j1 = cmp (b, S); + if ((j1 > 0 || (j1 == 0 && dig & 1)) + && dig++ == '9') + goto round_9_up; + } + *s++ = dig; + goto ret; + } + if (j1 > 0) + { + if (dig == '9') + { /* possible if i == 1 */ + round_9_up: + *s++ = '9'; + goto roundoff; + } + *s++ = dig + 1; + goto ret; + } + *s++ = dig; + if (i == ilim) + break; + b = multadd (ptr, b, 10, 0); + if (mlo == mhi) + mlo = mhi = multadd (ptr, mhi, 10, 0); + else + { + mlo = multadd (ptr, mlo, 10, 0); + mhi = multadd (ptr, mhi, 10, 0); + } + } + } + else + for (i = 1;; i++) + { + *s++ = dig = quorem (b, S) + '0'; + if (i >= ilim) + break; + b = multadd (ptr, b, 10, 0); + } + + /* Round off last digit */ + + b = lshift (ptr, b, 1); + j = cmp (b, S); + if (j > 0 || (j == 0 && dig & 1)) + { + roundoff: + while (*--s == '9') + if (s == s0) + { + k++; + *s++ = '1'; + goto ret; + } + ++*s++; + } + else + { + while (*--s == '0'); + s++; + } +ret: + Bfree (ptr, S); + if (mhi) + { + if (mlo && mlo != mhi) + Bfree (ptr, mlo); + Bfree (ptr, mhi); + } +ret1: + Bfree (ptr, b); + *s = 0; + *decpt = k + 1; + if (rve) + *rve = s; + return s0; +} + + +_VOID +_DEFUN (_dtoa, + (_d, mode, ndigits, decpt, sign, rve, buf, float_type), + double _d _AND + int mode _AND + int ndigits _AND + int *decpt _AND + int *sign _AND + char **rve _AND + char *buf _AND + int float_type) +{ + struct _Jv_reent reent; + char *p; + memset (&reent, 0, sizeof reent); + + p = _dtoa_r (&reent, _d, mode, ndigits, decpt, sign, rve, float_type); + strcpy (buf, p); + + return; +} + + diff --git a/libjava/java/lang/e_acos.c b/libjava/java/lang/e_acos.c new file mode 100644 index 00000000000..319b1d56fa0 --- /dev/null +++ b/libjava/java/lang/e_acos.c @@ -0,0 +1,111 @@ + +/* @(#)e_acos.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_acos(x) + * Method : + * acos(x) = pi/2 - asin(x) + * acos(-x) = pi/2 + asin(x) + * For |x|<=0.5 + * acos(x) = pi/2 - (x + x*x^2*R(x^2)) (see asin.c) + * For x>0.5 + * acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2))) + * = 2asin(sqrt((1-x)/2)) + * = 2s + 2s*z*R(z) ...z=(1-x)/2, s=sqrt(z) + * = 2f + (2c + 2s*z*R(z)) + * where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term + * for f so that f+c ~ sqrt(z). + * For x<-0.5 + * acos(x) = pi - 2asin(sqrt((1-|x|)/2)) + * = pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z) + * + * Special cases: + * if x is NaN, return x itself; + * if |x|>1, return NaN with invalid signal. + * + * Function needed: sqrt + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +one= 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ +pi = 3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */ +pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */ +pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */ +pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */ +pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */ +pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */ +pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */ +pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */ +pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */ +qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */ +qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */ +qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */ +qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */ + +#ifdef __STDC__ + double __ieee754_acos(double x) +#else + double __ieee754_acos(x) + double x; +#endif +{ + double z,p,q,r,w,s,c,df; + __int32_t hx,ix; + GET_HIGH_WORD(hx,x); + ix = hx&0x7fffffff; + if(ix>=0x3ff00000) { /* |x| >= 1 */ + __uint32_t lx; + GET_LOW_WORD(lx,x); + if(((ix-0x3ff00000)|lx)==0) { /* |x|==1 */ + if(hx>0) return 0.0; /* acos(1) = 0 */ + else return pi+2.0*pio2_lo; /* acos(-1)= pi */ + } + return (x-x)/(x-x); /* acos(|x|>1) is NaN */ + } + if(ix<0x3fe00000) { /* |x| < 0.5 */ + if(ix<=0x3c600000) return pio2_hi+pio2_lo;/*if|x|<2**-57*/ + z = x*x; + p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5))))); + q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4))); + r = p/q; + return pio2_hi - (x - (pio2_lo-x*r)); + } else if (hx<0) { /* x < -0.5 */ + z = (one+x)*0.5; + p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5))))); + q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4))); + s = __ieee754_sqrt(z); + r = p/q; + w = r*s-pio2_lo; + return pi - 2.0*(s+w); + } else { /* x > 0.5 */ + z = (one-x)*0.5; + s = __ieee754_sqrt(z); + df = s; + SET_LOW_WORD(df,0); + c = (z-df*df)/(s+df); + p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5))))); + q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4))); + r = p/q; + w = r*s+c; + return 2.0*(df+w); + } +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_asin.c b/libjava/java/lang/e_asin.c new file mode 100644 index 00000000000..559f2884a26 --- /dev/null +++ b/libjava/java/lang/e_asin.c @@ -0,0 +1,120 @@ + +/* @(#)e_asin.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_asin(x) + * Method : + * Since asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ... + * we approximate asin(x) on [0,0.5] by + * asin(x) = x + x*x^2*R(x^2) + * where + * R(x^2) is a rational approximation of (asin(x)-x)/x^3 + * and its remez error is bounded by + * |(asin(x)-x)/x^3 - R(x^2)| < 2^(-58.75) + * + * For x in [0.5,1] + * asin(x) = pi/2-2*asin(sqrt((1-x)/2)) + * Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2; + * then for x>0.98 + * asin(x) = pi/2 - 2*(s+s*z*R(z)) + * = pio2_hi - (2*(s+s*z*R(z)) - pio2_lo) + * For x<=0.98, let pio4_hi = pio2_hi/2, then + * f = hi part of s; + * c = sqrt(z) - f = (z-f*f)/(s+f) ...f+c=sqrt(z) + * and + * asin(x) = pi/2 - 2*(s+s*z*R(z)) + * = pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo) + * = pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c)) + * + * Special cases: + * if x is NaN, return x itself; + * if |x|>1, return NaN with invalid signal. + * + */ + + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ +huge = 1.000e+300, +pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */ +pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */ +pio4_hi = 7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */ + /* coefficient for R(x^2) */ +pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */ +pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */ +pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */ +pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */ +pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */ +pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */ +qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */ +qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */ +qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */ +qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */ + +#ifdef __STDC__ + double __ieee754_asin(double x) +#else + double __ieee754_asin(x) + double x; +#endif +{ + double t,w,p,q,c,r,s; + __int32_t hx,ix; + GET_HIGH_WORD(hx,x); + ix = hx&0x7fffffff; + if(ix>= 0x3ff00000) { /* |x|>= 1 */ + __uint32_t lx; + GET_LOW_WORD(lx,x); + if(((ix-0x3ff00000)|lx)==0) + /* asin(1)=+-pi/2 with inexact */ + return x*pio2_hi+x*pio2_lo; + return (x-x)/(x-x); /* asin(|x|>1) is NaN */ + } else if (ix<0x3fe00000) { /* |x|<0.5 */ + if(ix<0x3e400000) { /* if |x| < 2**-27 */ + if(huge+x>one) return x;/* return x with inexact if x!=0*/ + } else + t = x*x; + p = t*(pS0+t*(pS1+t*(pS2+t*(pS3+t*(pS4+t*pS5))))); + q = one+t*(qS1+t*(qS2+t*(qS3+t*qS4))); + w = p/q; + return x+x*w; + } + /* 1> |x|>= 0.5 */ + w = one-fabs(x); + t = w*0.5; + p = t*(pS0+t*(pS1+t*(pS2+t*(pS3+t*(pS4+t*pS5))))); + q = one+t*(qS1+t*(qS2+t*(qS3+t*qS4))); + s = __ieee754_sqrt(t); + if(ix>=0x3FEF3333) { /* if |x| > 0.975 */ + w = p/q; + t = pio2_hi-(2.0*(s+s*w)-pio2_lo); + } else { + w = s; + SET_LOW_WORD(w,0); + c = (t-w*w)/(s+w); + r = p/q; + p = 2.0*s*r-(pio2_lo-2.0*c); + q = pio4_hi-2.0*w; + t = pio4_hi-(p-q); + } + if(hx>0) return t; else return -t; +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_atan2.c b/libjava/java/lang/e_atan2.c new file mode 100644 index 00000000000..8e9650f290d --- /dev/null +++ b/libjava/java/lang/e_atan2.c @@ -0,0 +1,131 @@ + +/* @(#)e_atan2.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* __ieee754_atan2(y,x) + * Method : + * 1. Reduce y to positive by atan2(y,x)=-atan2(-y,x). + * 2. Reduce x to positive by (if x and y are unexceptional): + * ARG (x+iy) = arctan(y/x) ... if x > 0, + * ARG (x+iy) = pi - arctan[y/(-x)] ... if x < 0, + * + * Special cases: + * + * ATAN2((anything), NaN ) is NaN; + * ATAN2(NAN , (anything) ) is NaN; + * ATAN2(+-0, +(anything but NaN)) is +-0 ; + * ATAN2(+-0, -(anything but NaN)) is +-pi ; + * ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2; + * ATAN2(+-(anything but INF and NaN), +INF) is +-0 ; + * ATAN2(+-(anything but INF and NaN), -INF) is +-pi; + * ATAN2(+-INF,+INF ) is +-pi/4 ; + * ATAN2(+-INF,-INF ) is +-3pi/4; + * ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2; + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +tiny = 1.0e-300, +zero = 0.0, +pi_o_4 = 7.8539816339744827900E-01, /* 0x3FE921FB, 0x54442D18 */ +pi_o_2 = 1.5707963267948965580E+00, /* 0x3FF921FB, 0x54442D18 */ +pi = 3.1415926535897931160E+00, /* 0x400921FB, 0x54442D18 */ +pi_lo = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */ + +#ifdef __STDC__ + double __ieee754_atan2(double y, double x) +#else + double __ieee754_atan2(y,x) + double y,x; +#endif +{ + double z; + __int32_t k,m,hx,hy,ix,iy; + __uint32_t lx,ly; + + EXTRACT_WORDS(hx,lx,x); + ix = hx&0x7fffffff; + EXTRACT_WORDS(hy,ly,y); + iy = hy&0x7fffffff; + if(((ix|((lx|-lx)>>31))>0x7ff00000)|| + ((iy|((ly|-ly)>>31))>0x7ff00000)) /* x or y is NaN */ + return x+y; + if(((hx-0x3ff00000)|lx)==0) return atan(y); /* x=1.0 */ + m = ((hy>>31)&1)|((hx>>30)&2); /* 2*sign(x)+sign(y) */ + + /* when y = 0 */ + if((iy|ly)==0) { + switch(m) { + case 0: + case 1: return y; /* atan(+-0,+anything)=+-0 */ + case 2: return pi+tiny;/* atan(+0,-anything) = pi */ + case 3: return -pi-tiny;/* atan(-0,-anything) =-pi */ + } + } + /* when x = 0 */ + if((ix|lx)==0) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny; + + /* when x is INF */ + if(ix==0x7ff00000) { + if(iy==0x7ff00000) { + switch(m) { + case 0: return pi_o_4+tiny;/* atan(+INF,+INF) */ + case 1: return -pi_o_4-tiny;/* atan(-INF,+INF) */ + case 2: return 3.0*pi_o_4+tiny;/*atan(+INF,-INF)*/ + case 3: return -3.0*pi_o_4-tiny;/*atan(-INF,-INF)*/ + } + } else { + switch(m) { + case 0: return zero ; /* atan(+...,+INF) */ + case 1: return -zero ; /* atan(-...,+INF) */ + case 2: return pi+tiny ; /* atan(+...,-INF) */ + case 3: return -pi-tiny ; /* atan(-...,-INF) */ + } + } + } + /* when y is INF */ + if(iy==0x7ff00000) return (hy<0)? -pi_o_2-tiny: pi_o_2+tiny; + + /* compute y/x */ + k = (iy-ix)>>20; + if(k > 60) z=pi_o_2+0.5*pi_lo; /* |y/x| > 2**60 */ + else if(hx<0&&k<-60) z=0.0; /* |y|/x < -2**60 */ + else z=atan(fabs(y/x)); /* safe to do y/x */ + switch (m) { + case 0: return z ; /* atan(+,+) */ + case 1: { + __uint32_t zh; + GET_HIGH_WORD(zh,z); + SET_HIGH_WORD(z,zh ^ 0x80000000); + } + return z ; /* atan(-,+) */ + case 2: return pi-(z-pi_lo);/* atan(+,-) */ + default: /* case 3 */ + return (z-pi_lo)-pi;/* atan(-,-) */ + } +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_exp.c b/libjava/java/lang/e_exp.c new file mode 100644 index 00000000000..ce093c61065 --- /dev/null +++ b/libjava/java/lang/e_exp.c @@ -0,0 +1,167 @@ + +/* @(#)e_exp.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_exp(x) + * Returns the exponential of x. + * + * Method + * 1. Argument reduction: + * Reduce x to an r so that |r| <= 0.5*ln2 ~ 0.34658. + * Given x, find r and integer k such that + * + * x = k*ln2 + r, |r| <= 0.5*ln2. + * + * Here r will be represented as r = hi-lo for better + * accuracy. + * + * 2. Approximation of exp(r) by a special rational function on + * the interval [0,0.34658]: + * Write + * R(r**2) = r*(exp(r)+1)/(exp(r)-1) = 2 + r*r/6 - r**4/360 + ... + * We use a special Reme algorithm on [0,0.34658] to generate + * a polynomial of degree 5 to approximate R. The maximum error + * of this polynomial approximation is bounded by 2**-59. In + * other words, + * R(z) ~ 2.0 + P1*z + P2*z**2 + P3*z**3 + P4*z**4 + P5*z**5 + * (where z=r*r, and the values of P1 to P5 are listed below) + * and + * | 5 | -59 + * | 2.0+P1*z+...+P5*z - R(z) | <= 2 + * | | + * The computation of exp(r) thus becomes + * 2*r + * exp(r) = 1 + ------- + * R - r + * r*R1(r) + * = 1 + r + ----------- (for better accuracy) + * 2 - R1(r) + * where + * 2 4 10 + * R1(r) = r - (P1*r + P2*r + ... + P5*r ). + * + * 3. Scale back to obtain exp(x): + * From step 1, we have + * exp(x) = 2^k * exp(r) + * + * Special cases: + * exp(INF) is INF, exp(NaN) is NaN; + * exp(-INF) is 0, and + * for finite argument, only exp(0)=1 is exact. + * + * Accuracy: + * according to an error analysis, the error is always less than + * 1 ulp (unit in the last place). + * + * Misc. info. + * For IEEE double + * if x > 7.09782712893383973096e+02 then exp(x) overflow + * if x < -7.45133219101941108420e+02 then exp(x) underflow + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +one = 1.0, +halF[2] = {0.5,-0.5,}, +huge = 1.0e+300, +twom1000= 9.33263618503218878990e-302, /* 2**-1000=0x01700000,0*/ +o_threshold= 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */ +u_threshold= -7.45133219101941108420e+02, /* 0xc0874910, 0xD52D3051 */ +ln2HI[2] ={ 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */ + -6.93147180369123816490e-01,},/* 0xbfe62e42, 0xfee00000 */ +ln2LO[2] ={ 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */ + -1.90821492927058770002e-10,},/* 0xbdea39ef, 0x35793c76 */ +invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */ +P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */ +P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */ +P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */ +P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */ +P5 = 4.13813679705723846039e-08; /* 0x3E663769, 0x72BEA4D0 */ + + +#ifdef __STDC__ + double __ieee754_exp(double x) /* default IEEE double exp */ +#else + double __ieee754_exp(x) /* default IEEE double exp */ + double x; +#endif +{ + double y,hi,lo,c,t; + __int32_t k,xsb; + __uint32_t hx; + + GET_HIGH_WORD(hx,x); + xsb = (hx>>31)&1; /* sign bit of x */ + hx &= 0x7fffffff; /* high word of |x| */ + + /* filter out non-finite argument */ + if(hx >= 0x40862E42) { /* if |x|>=709.78... */ + if(hx>=0x7ff00000) { + __uint32_t lx; + GET_LOW_WORD(lx,x); + if(((hx&0xfffff)|lx)!=0) + return x+x; /* NaN */ + else return (xsb==0)? x:0.0; /* exp(+-inf)={inf,0} */ + } + if(x > o_threshold) return huge*huge; /* overflow */ + if(x < u_threshold) return twom1000*twom1000; /* underflow */ + } + + /* argument reduction */ + if(hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */ + if(hx < 0x3FF0A2B2) { /* and |x| < 1.5 ln2 */ + hi = x-ln2HI[xsb]; lo=ln2LO[xsb]; k = 1-xsb-xsb; + } else { + k = invln2*x+halF[xsb]; + t = k; + hi = x - t*ln2HI[0]; /* t*ln2HI is exact here */ + lo = t*ln2LO[0]; + } + x = hi - lo; + } + else if(hx < 0x3e300000) { /* when |x|<2**-28 */ + if(huge+x>one) return one+x;/* trigger inexact */ + } + else k = 0; + + /* x is now in primary range */ + t = x*x; + c = x - t*(P1+t*(P2+t*(P3+t*(P4+t*P5)))); + if(k==0) return one-((x*c)/(c-2.0)-x); + else y = one-((lo-(x*c)/(2.0-c))-hi); + if(k >= -1021) { + __uint32_t hy; + GET_HIGH_WORD(hy,y); + SET_HIGH_WORD(y,hy+(k<<20)); /* add k to y's exponent */ + return y; + } else { + __uint32_t hy; + GET_HIGH_WORD(hy,y); + SET_HIGH_WORD(y,hy+((k+1000)<<20)); /* add k to y's exponent */ + return y*twom1000; + } +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_fmod.c b/libjava/java/lang/e_fmod.c new file mode 100644 index 00000000000..f9739eec25d --- /dev/null +++ b/libjava/java/lang/e_fmod.c @@ -0,0 +1,140 @@ + +/* @(#)e_fmod.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __ieee754_fmod(x,y) + * Return x mod y in exact arithmetic + * Method: shift and subtract + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double one = 1.0, Zero[] = {0.0, -0.0,}; +#else +static double one = 1.0, Zero[] = {0.0, -0.0,}; +#endif + +#ifdef __STDC__ + double __ieee754_fmod(double x, double y) +#else + double __ieee754_fmod(x,y) + double x,y ; +#endif +{ + __int32_t n,hx,hy,hz,ix,iy,sx,i; + __uint32_t lx,ly,lz; + + EXTRACT_WORDS(hx,lx,x); + EXTRACT_WORDS(hy,ly,y); + sx = hx&0x80000000; /* sign of x */ + hx ^=sx; /* |x| */ + hy &= 0x7fffffff; /* |y| */ + + /* purge off exception values */ + if((hy|ly)==0||(hx>=0x7ff00000)|| /* y=0,or x not finite */ + ((hy|((ly|-ly)>>31))>0x7ff00000)) /* or y is NaN */ + return (x*y)/(x*y); + if(hx<=hy) { + if((hx>31]; /* |x|=|y| return x*0*/ + } + + /* determine ix = ilogb(x) */ + if(hx<0x00100000) { /* subnormal x */ + if(hx==0) { + for (ix = -1043, i=lx; i>0; i<<=1) ix -=1; + } else { + for (ix = -1022,i=(hx<<11); i>0; i<<=1) ix -=1; + } + } else ix = (hx>>20)-1023; + + /* determine iy = ilogb(y) */ + if(hy<0x00100000) { /* subnormal y */ + if(hy==0) { + for (iy = -1043, i=ly; i>0; i<<=1) iy -=1; + } else { + for (iy = -1022,i=(hy<<11); i>0; i<<=1) iy -=1; + } + } else iy = (hy>>20)-1023; + + /* set up {hx,lx}, {hy,ly} and align y to x */ + if(ix >= -1022) + hx = 0x00100000|(0x000fffff&hx); + else { /* subnormal x, shift x to normal */ + n = -1022-ix; + if(n<=31) { + hx = (hx<>(32-n)); + lx <<= n; + } else { + hx = lx<<(n-32); + lx = 0; + } + } + if(iy >= -1022) + hy = 0x00100000|(0x000fffff&hy); + else { /* subnormal y, shift y to normal */ + n = -1022-iy; + if(n<=31) { + hy = (hy<>(32-n)); + ly <<= n; + } else { + hy = ly<<(n-32); + ly = 0; + } + } + + /* fix point fmod */ + n = ix - iy; + while(n--) { + hz=hx-hy;lz=lx-ly; if(lx>31); lx = lx+lx;} + else { + if((hz|lz)==0) /* return sign(x)*0 */ + return Zero[(__uint32_t)sx>>31]; + hx = hz+hz+(lz>>31); lx = lz+lz; + } + } + hz=hx-hy;lz=lx-ly; if(lx=0) {hx=hz;lx=lz;} + + /* convert back to floating value and restore the sign */ + if((hx|lx)==0) /* return sign(x)*0 */ + return Zero[(__uint32_t)sx>>31]; + while(hx<0x00100000) { /* normalize x */ + hx = hx+hx+(lx>>31); lx = lx+lx; + iy -= 1; + } + if(iy>= -1022) { /* normalize output */ + hx = ((hx-0x00100000)|((iy+1023)<<20)); + INSERT_WORDS(x,hx|sx,lx); + } else { /* subnormal output */ + n = -1022 - iy; + if(n<=20) { + lx = (lx>>n)|((__uint32_t)hx<<(32-n)); + hx >>= n; + } else if (n<=31) { + lx = (hx<<(32-n))|(lx>>n); hx = sx; + } else { + lx = hx>>(n-32); hx = sx; + } + INSERT_WORDS(x,hx|sx,lx); + x *= one; /* create necessary signal */ + } + return x; /* exact output */ +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_log.c b/libjava/java/lang/e_log.c new file mode 100644 index 00000000000..ea6c55f6c36 --- /dev/null +++ b/libjava/java/lang/e_log.c @@ -0,0 +1,152 @@ + +/* @(#)e_log.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_log(x) + * Return the logrithm of x + * + * Method : + * 1. Argument Reduction: find k and f such that + * x = 2^k * (1+f), + * where sqrt(2)/2 < 1+f < sqrt(2) . + * + * 2. Approximation of log(1+f). + * Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s) + * = 2s + 2/3 s**3 + 2/5 s**5 + ....., + * = 2s + s*R + * We use a special Reme algorithm on [0,0.1716] to generate + * a polynomial of degree 14 to approximate R The maximum error + * of this polynomial approximation is bounded by 2**-58.45. In + * other words, + * 2 4 6 8 10 12 14 + * R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s +Lg6*s +Lg7*s + * (the values of Lg1 to Lg7 are listed in the program) + * and + * | 2 14 | -58.45 + * | Lg1*s +...+Lg7*s - R(z) | <= 2 + * | | + * Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2. + * In order to guarantee error in log below 1ulp, we compute log + * by + * log(1+f) = f - s*(f - R) (if f is not too large) + * log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy) + * + * 3. Finally, log(x) = k*ln2 + log(1+f). + * = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo))) + * Here ln2 is split into two floating point number: + * ln2_hi + ln2_lo, + * where n*ln2_hi is always exact for |n| < 2000. + * + * Special cases: + * log(x) is NaN with signal if x < 0 (including -INF) ; + * log(+INF) is +INF; log(0) is -INF with signal; + * log(NaN) is that NaN with no signal. + * + * Accuracy: + * according to an error analysis, the error is always less than + * 1 ulp (unit in the last place). + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +ln2_hi = 6.93147180369123816490e-01, /* 3fe62e42 fee00000 */ +ln2_lo = 1.90821492927058770002e-10, /* 3dea39ef 35793c76 */ +two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */ +Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */ +Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */ +Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */ +Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */ +Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */ +Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */ +Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */ + +#ifdef __STDC__ +static const double zero = 0.0; +#else +static double zero = 0.0; +#endif + +#ifdef __STDC__ + double __ieee754_log(double x) +#else + double __ieee754_log(x) + double x; +#endif +{ + double hfsq,f,s,z,R,w,t1,t2,dk; + __int32_t k,hx,i,j; + __uint32_t lx; + + EXTRACT_WORDS(hx,lx,x); + + k=0; + if (hx < 0x00100000) { /* x < 2**-1022 */ + if (((hx&0x7fffffff)|lx)==0) + return -two54/zero; /* log(+-0)=-inf */ + if (hx<0) return (x-x)/zero; /* log(-#) = NaN */ + k -= 54; x *= two54; /* subnormal number, scale up x */ + GET_HIGH_WORD(hx,x); + } + if (hx >= 0x7ff00000) return x+x; + k += (hx>>20)-1023; + hx &= 0x000fffff; + i = (hx+0x95f64)&0x100000; + SET_HIGH_WORD(x,hx|(i^0x3ff00000)); /* normalize x or x/2 */ + k += (i>>20); + f = x-1.0; + if((0x000fffff&(2+hx))<3) { /* |f| < 2**-20 */ + if(f==zero) { + if(k==0) + return zero; + else { + dk=(double)k; + return dk*ln2_hi+dk*ln2_lo; + } + } + R = f*f*(0.5-0.33333333333333333*f); + if(k==0) return f-R; else {dk=(double)k; + return dk*ln2_hi-((R-dk*ln2_lo)-f);} + } + s = f/(2.0+f); + dk = (double)k; + z = s*s; + i = hx-0x6147a; + w = z*z; + j = 0x6b851-hx; + t1= w*(Lg2+w*(Lg4+w*Lg6)); + t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7))); + i |= j; + R = t2+t1; + if(i>0) { + hfsq=0.5*f*f; + if(k==0) return f-(hfsq-s*(hfsq+R)); else + return dk*ln2_hi-((hfsq-(s*(hfsq+R)+dk*ln2_lo))-f); + } else { + if(k==0) return f-s*(f-R); else + return dk*ln2_hi-((s*(f-R)-dk*ln2_lo)-f); + } +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_pow.c b/libjava/java/lang/e_pow.c new file mode 100644 index 00000000000..f078dff344d --- /dev/null +++ b/libjava/java/lang/e_pow.c @@ -0,0 +1,312 @@ + +/* @(#)e_pow.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_pow(x,y) return x**y + * + * n + * Method: Let x = 2 * (1+f) + * 1. Compute and return log2(x) in two pieces: + * log2(x) = w1 + w2, + * where w1 has 53-24 = 29 bit trailing zeros. + * 2. Perform y*log2(x) = n+y' by simulating muti-precision + * arithmetic, where |y'|<=0.5. + * 3. Return x**y = 2**n*exp(y'*log2) + * + * Special cases: + * 1. (anything) ** 0 is 1 + * 2. (anything) ** 1 is itself + * 3. (anything) ** NAN is NAN + * 4. NAN ** (anything except 0) is NAN + * 5. +-(|x| > 1) ** +INF is +INF + * 6. +-(|x| > 1) ** -INF is +0 + * 7. +-(|x| < 1) ** +INF is +0 + * 8. +-(|x| < 1) ** -INF is +INF + * 9. +-1 ** +-INF is NAN + * 10. +0 ** (+anything except 0, NAN) is +0 + * 11. -0 ** (+anything except 0, NAN, odd integer) is +0 + * 12. +0 ** (-anything except 0, NAN) is +INF + * 13. -0 ** (-anything except 0, NAN, odd integer) is +INF + * 14. -0 ** (odd integer) = -( +0 ** (odd integer) ) + * 15. +INF ** (+anything except 0,NAN) is +INF + * 16. +INF ** (-anything except 0,NAN) is +0 + * 17. -INF ** (anything) = -0 ** (-anything) + * 18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer) + * 19. (-anything except 0 and inf) ** (non-integer) is NAN + * + * Accuracy: + * pow(x,y) returns x**y nearly rounded. In particular + * pow(integer,integer) + * always returns the correct integer provided it is + * representable. + * + * Constants : + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +bp[] = {1.0, 1.5,}, +dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */ +dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */ +zero = 0.0, +one = 1.0, +two = 2.0, +two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */ +huge = 1.0e300, +tiny = 1.0e-300, + /* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */ +L1 = 5.99999999999994648725e-01, /* 0x3FE33333, 0x33333303 */ +L2 = 4.28571428578550184252e-01, /* 0x3FDB6DB6, 0xDB6FABFF */ +L3 = 3.33333329818377432918e-01, /* 0x3FD55555, 0x518F264D */ +L4 = 2.72728123808534006489e-01, /* 0x3FD17460, 0xA91D4101 */ +L5 = 2.30660745775561754067e-01, /* 0x3FCD864A, 0x93C9DB65 */ +L6 = 2.06975017800338417784e-01, /* 0x3FCA7E28, 0x4A454EEF */ +P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */ +P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */ +P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */ +P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */ +P5 = 4.13813679705723846039e-08, /* 0x3E663769, 0x72BEA4D0 */ +lg2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */ +lg2_h = 6.93147182464599609375e-01, /* 0x3FE62E43, 0x00000000 */ +lg2_l = -1.90465429995776804525e-09, /* 0xBE205C61, 0x0CA86C39 */ +ovt = 8.0085662595372944372e-0017, /* -(1024-log2(ovfl+.5ulp)) */ +cp = 9.61796693925975554329e-01, /* 0x3FEEC709, 0xDC3A03FD =2/(3ln2) */ +cp_h = 9.61796700954437255859e-01, /* 0x3FEEC709, 0xE0000000 =(float)cp */ +cp_l = -7.02846165095275826516e-09, /* 0xBE3E2FE0, 0x145B01F5 =tail of cp_h*/ +ivln2 = 1.44269504088896338700e+00, /* 0x3FF71547, 0x652B82FE =1/ln2 */ +ivln2_h = 1.44269502162933349609e+00, /* 0x3FF71547, 0x60000000 =24b 1/ln2*/ +ivln2_l = 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/ + +#ifdef __STDC__ + double __ieee754_pow(double x, double y) +#else + double __ieee754_pow(x,y) + double x, y; +#endif +{ + double z,ax,z_h,z_l,p_h,p_l; + double y1,t1,t2,r,s,t,u,v,w; + __int32_t i,j,k,yisint,n; + __int32_t hx,hy,ix,iy; + __uint32_t lx,ly; + + EXTRACT_WORDS(hx,lx,x); + EXTRACT_WORDS(hy,ly,y); + ix = hx&0x7fffffff; iy = hy&0x7fffffff; + + /* y==zero: x**0 = 1 */ + if((iy|ly)==0) return one; + + /* +-NaN return x+y */ + if(ix > 0x7ff00000 || ((ix==0x7ff00000)&&(lx!=0)) || + iy > 0x7ff00000 || ((iy==0x7ff00000)&&(ly!=0))) + return x+y; + + /* determine if y is an odd int when x < 0 + * yisint = 0 ... y is not an integer + * yisint = 1 ... y is an odd int + * yisint = 2 ... y is an even int + */ + yisint = 0; + if(hx<0) { + if(iy>=0x43400000) yisint = 2; /* even integer y */ + else if(iy>=0x3ff00000) { + k = (iy>>20)-0x3ff; /* exponent */ + if(k>20) { + j = ly>>(52-k); + if((__uint32_t)(j<<(52-k))==ly) yisint = 2-(j&1); + } else if(ly==0) { + j = iy>>(20-k); + if((j<<(20-k))==iy) yisint = 2-(j&1); + } + } + } + + /* special value of y */ + if(ly==0) { + if (iy==0x7ff00000) { /* y is +-inf */ + if(((ix-0x3ff00000)|lx)==0) + return y - y; /* inf**+-1 is NaN */ + else if (ix >= 0x3ff00000)/* (|x|>1)**+-inf = inf,0 */ + return (hy>=0)? y: zero; + else /* (|x|<1)**-,+inf = inf,0 */ + return (hy<0)?-y: zero; + } + if(iy==0x3ff00000) { /* y is +-1 */ + if(hy<0) return one/x; else return x; + } + if(hy==0x40000000) return x*x; /* y is 2 */ + if(hy==0x3fe00000) { /* y is 0.5 */ + if(hx>=0) /* x >= +0 */ + return __ieee754_sqrt(x); + } + } + + ax = fabs(x); + /* special value of x */ + if(lx==0) { + if(ix==0x7ff00000||ix==0||ix==0x3ff00000){ + z = ax; /*x is +-0,+-inf,+-1*/ + if(hy<0) z = one/z; /* z = (1/|x|) */ + if(hx<0) { + if(((ix-0x3ff00000)|yisint)==0) { + z = (z-z)/(z-z); /* (-1)**non-int is NaN */ + } else if(yisint==1) + z = -z; /* (x<0)**odd = -(|x|**odd) */ + } + return z; + } + } + + /* (x<0)**(non-int) is NaN */ + /* CYGNUS LOCAL: This used to be + if((((hx>>31)+1)|yisint)==0) return (x-x)/(x-x); + but ANSI C says a right shift of a signed negative quantity is + implementation defined. */ + if(((((__uint32_t)hx>>31)-1)|yisint)==0) return (x-x)/(x-x); + + /* |y| is huge */ + if(iy>0x41e00000) { /* if |y| > 2**31 */ + if(iy>0x43f00000){ /* if |y| > 2**64, must o/uflow */ + if(ix<=0x3fefffff) return (hy<0)? huge*huge:tiny*tiny; + if(ix>=0x3ff00000) return (hy>0)? huge*huge:tiny*tiny; + } + /* over/underflow if x is not close to one */ + if(ix<0x3fefffff) return (hy<0)? huge*huge:tiny*tiny; + if(ix>0x3ff00000) return (hy>0)? huge*huge:tiny*tiny; + /* now |1-x| is tiny <= 2**-20, suffice to compute + log(x) by x-x^2/2+x^3/3-x^4/4 */ + t = x-1; /* t has 20 trailing zeros */ + w = (t*t)*(0.5-t*(0.3333333333333333333333-t*0.25)); + u = ivln2_h*t; /* ivln2_h has 21 sig. bits */ + v = t*ivln2_l-w*ivln2; + t1 = u+v; + SET_LOW_WORD(t1,0); + t2 = v-(t1-u); + } else { + double s2,s_h,s_l,t_h,t_l; + n = 0; + /* take care subnormal number */ + if(ix<0x00100000) + {ax *= two53; n -= 53; GET_HIGH_WORD(ix,ax); } + n += ((ix)>>20)-0x3ff; + j = ix&0x000fffff; + /* determine interval */ + ix = j|0x3ff00000; /* normalize ix */ + if(j<=0x3988E) k=0; /* |x|>1)|0x20000000)+0x00080000+(k<<18)); + t_l = ax - (t_h-bp[k]); + s_l = v*((u-s_h*t_h)-s_h*t_l); + /* compute log(ax) */ + s2 = s*s; + r = s2*s2*(L1+s2*(L2+s2*(L3+s2*(L4+s2*(L5+s2*L6))))); + r += s_l*(s_h+s); + s2 = s_h*s_h; + t_h = 3.0+s2+r; + SET_LOW_WORD(t_h,0); + t_l = r-((t_h-3.0)-s2); + /* u+v = s*(1+...) */ + u = s_h*t_h; + v = s_l*t_h+t_l*s; + /* 2/(3log2)*(s+...) */ + p_h = u+v; + SET_LOW_WORD(p_h,0); + p_l = v-(p_h-u); + z_h = cp_h*p_h; /* cp_h+cp_l = 2/(3*log2) */ + z_l = cp_l*p_h+p_l*cp+dp_l[k]; + /* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */ + t = (double)n; + t1 = (((z_h+z_l)+dp_h[k])+t); + SET_LOW_WORD(t1,0); + t2 = z_l-(((t1-t)-dp_h[k])-z_h); + } + + s = one; /* s (sign of result -ve**odd) = -1 else = 1 */ + if(((((__uint32_t)hx>>31)-1)|(yisint-1))==0) + s = -one;/* (-ve)**(odd int) */ + + /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */ + y1 = y; + SET_LOW_WORD(y1,0); + p_l = (y-y1)*t1+y*t2; + p_h = y1*t1; + z = p_l+p_h; + EXTRACT_WORDS(j,i,z); + if (j>=0x40900000) { /* z >= 1024 */ + if(((j-0x40900000)|i)!=0) /* if z > 1024 */ + return s*huge*huge; /* overflow */ + else { + if(p_l+ovt>z-p_h) return s*huge*huge; /* overflow */ + } + } else if((j&0x7fffffff)>=0x4090cc00 ) { /* z <= -1075 */ + if(((j-0xc090cc00)|i)!=0) /* z < -1075 */ + return s*tiny*tiny; /* underflow */ + else { + if(p_l<=z-p_h) return s*tiny*tiny; /* underflow */ + } + } + /* + * compute 2**(p_h+p_l) + */ + i = j&0x7fffffff; + k = (i>>20)-0x3ff; + n = 0; + if(i>0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */ + n = j+(0x00100000>>(k+1)); + k = ((n&0x7fffffff)>>20)-0x3ff; /* new k for n */ + t = zero; + SET_HIGH_WORD(t,n&~(0x000fffff>>k)); + n = ((n&0x000fffff)|0x00100000)>>(20-k); + if(j<0) n = -n; + p_h -= t; + } + t = p_l+p_h; + SET_LOW_WORD(t,0); + u = t*lg2_h; + v = (p_l-(t-p_h))*lg2+t*lg2_l; + z = u+v; + w = v-(z-u); + t = z*z; + t1 = z - t*(P1+t*(P2+t*(P3+t*(P4+t*P5)))); + r = (z*t1)/(t1-two)-(w+z*w); + z = one-(r-z); + GET_HIGH_WORD(j,z); + j += (n<<20); + if((j>>20)<=0) z = scalbn(z,(int)n); /* subnormal output */ + else SET_HIGH_WORD(z,j); + return s*z; +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_rem_pio2.c b/libjava/java/lang/e_rem_pio2.c new file mode 100644 index 00000000000..3e5d0f7a227 --- /dev/null +++ b/libjava/java/lang/e_rem_pio2.c @@ -0,0 +1,185 @@ + +/* @(#)e_rem_pio2.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* __ieee754_rem_pio2(x,y) + * + * return the remainder of x rem pi/2 in y[0]+y[1] + * use __kernel_rem_pio2() + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +/* + * Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi + */ +#ifdef __STDC__ +static const __int32_t two_over_pi[] = { +#else +static __int32_t two_over_pi[] = { +#endif +0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62, +0x95993C, 0x439041, 0xFE5163, 0xABDEBB, 0xC561B7, 0x246E3A, +0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C, 0xFE1DEB, 0x1CB129, +0xA73EE8, 0x8235F5, 0x2EBB44, 0x84E99C, 0x7026B4, 0x5F7E41, +0x3991D6, 0x398353, 0x39F49C, 0x845F8B, 0xBDF928, 0x3B1FF8, +0x97FFDE, 0x05980F, 0xEF2F11, 0x8B5A0A, 0x6D1F6D, 0x367ECF, +0x27CB09, 0xB74F46, 0x3F669E, 0x5FEA2D, 0x7527BA, 0xC7EBE5, +0xF17B3D, 0x0739F7, 0x8A5292, 0xEA6BFB, 0x5FB11F, 0x8D5D08, +0x560330, 0x46FC7B, 0x6BABF0, 0xCFBC20, 0x9AF436, 0x1DA9E3, +0x91615E, 0xE61B08, 0x659985, 0x5F14A0, 0x68408D, 0xFFD880, +0x4D7327, 0x310606, 0x1556CA, 0x73A8C9, 0x60E27B, 0xC08C6B, +}; + +#ifdef __STDC__ +static const __int32_t npio2_hw[] = { +#else +static __int32_t npio2_hw[] = { +#endif +0x3FF921FB, 0x400921FB, 0x4012D97C, 0x401921FB, 0x401F6A7A, 0x4022D97C, +0x4025FDBB, 0x402921FB, 0x402C463A, 0x402F6A7A, 0x4031475C, 0x4032D97C, +0x40346B9C, 0x4035FDBB, 0x40378FDB, 0x403921FB, 0x403AB41B, 0x403C463A, +0x403DD85A, 0x403F6A7A, 0x40407E4C, 0x4041475C, 0x4042106C, 0x4042D97C, +0x4043A28C, 0x40446B9C, 0x404534AC, 0x4045FDBB, 0x4046C6CB, 0x40478FDB, +0x404858EB, 0x404921FB, +}; + +/* + * invpio2: 53 bits of 2/pi + * pio2_1: first 33 bit of pi/2 + * pio2_1t: pi/2 - pio2_1 + * pio2_2: second 33 bit of pi/2 + * pio2_2t: pi/2 - (pio2_1+pio2_2) + * pio2_3: third 33 bit of pi/2 + * pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3) + */ + +#ifdef __STDC__ +static const double +#else +static double +#endif +zero = 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */ +half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */ +two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */ +invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */ +pio2_1 = 1.57079632673412561417e+00, /* 0x3FF921FB, 0x54400000 */ +pio2_1t = 6.07710050650619224932e-11, /* 0x3DD0B461, 0x1A626331 */ +pio2_2 = 6.07710050630396597660e-11, /* 0x3DD0B461, 0x1A600000 */ +pio2_2t = 2.02226624879595063154e-21, /* 0x3BA3198A, 0x2E037073 */ +pio2_3 = 2.02226624871116645580e-21, /* 0x3BA3198A, 0x2E000000 */ +pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */ + +#ifdef __STDC__ + __int32_t __ieee754_rem_pio2(double x, double *y) +#else + __int32_t __ieee754_rem_pio2(x,y) + double x,y[]; +#endif +{ + double z,w,t,r,fn; + double tx[3]; + __int32_t i,j,n,ix,hx; + int e0,nx; + __uint32_t low; + + GET_HIGH_WORD(hx,x); /* high word of x */ + ix = hx&0x7fffffff; + if(ix<=0x3fe921fb) /* |x| ~<= pi/4 , no need for reduction */ + {y[0] = x; y[1] = 0; return 0;} + if(ix<0x4002d97c) { /* |x| < 3pi/4, special case with n=+-1 */ + if(hx>0) { + z = x - pio2_1; + if(ix!=0x3ff921fb) { /* 33+53 bit pi is good enough */ + y[0] = z - pio2_1t; + y[1] = (z-y[0])-pio2_1t; + } else { /* near pi/2, use 33+33+53 bit pi */ + z -= pio2_2; + y[0] = z - pio2_2t; + y[1] = (z-y[0])-pio2_2t; + } + return 1; + } else { /* negative x */ + z = x + pio2_1; + if(ix!=0x3ff921fb) { /* 33+53 bit pi is good enough */ + y[0] = z + pio2_1t; + y[1] = (z-y[0])+pio2_1t; + } else { /* near pi/2, use 33+33+53 bit pi */ + z += pio2_2; + y[0] = z + pio2_2t; + y[1] = (z-y[0])+pio2_2t; + } + return -1; + } + } + if(ix<=0x413921fb) { /* |x| ~<= 2^19*(pi/2), medium size */ + t = fabs(x); + n = (__int32_t) (t*invpio2+half); + fn = (double)n; + r = t-fn*pio2_1; + w = fn*pio2_1t; /* 1st round good to 85 bit */ + if(n<32&&ix!=npio2_hw[n-1]) { + y[0] = r-w; /* quick check no cancellation */ + } else { + __uint32_t high; + j = ix>>20; + y[0] = r-w; + GET_HIGH_WORD(high,y[0]); + i = j-((high>>20)&0x7ff); + if(i>16) { /* 2nd iteration needed, good to 118 */ + t = r; + w = fn*pio2_2; + r = t-w; + w = fn*pio2_2t-((t-r)-w); + y[0] = r-w; + GET_HIGH_WORD(high,y[0]); + i = j-((high>>20)&0x7ff); + if(i>49) { /* 3rd iteration need, 151 bits acc */ + t = r; /* will cover all possible cases */ + w = fn*pio2_3; + r = t-w; + w = fn*pio2_3t-((t-r)-w); + y[0] = r-w; + } + } + } + y[1] = (r-y[0])-w; + if(hx<0) {y[0] = -y[0]; y[1] = -y[1]; return -n;} + else return n; + } + /* + * all other (large) arguments + */ + if(ix>=0x7ff00000) { /* x is inf or NaN */ + y[0]=y[1]=x-x; return 0; + } + /* set z = scalbn(|x|,ilogb(x)-23) */ + GET_LOW_WORD(low,x); + SET_LOW_WORD(z,low); + e0 = (int)((ix>>20)-1046); /* e0 = ilogb(z)-23; */ + SET_HIGH_WORD(z, ix - ((__int32_t)e0<<20)); + for(i=0;i<2;i++) { + tx[i] = (double)((__int32_t)(z)); + z = (z-tx[i])*two24; + } + tx[2] = z; + nx = 3; + while(tx[nx-1]==zero) nx--; /* skip zero term */ + n = __kernel_rem_pio2(tx,y,e0,nx,2,two_over_pi); + if(hx<0) {y[0] = -y[0]; y[1] = -y[1]; return -n;} + return n; +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_remainder.c b/libjava/java/lang/e_remainder.c new file mode 100644 index 00000000000..ae7ce649ad5 --- /dev/null +++ b/libjava/java/lang/e_remainder.c @@ -0,0 +1,80 @@ + +/* @(#)e_remainder.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_remainder(x,p) + * Return : + * returns x REM p = x - [x/p]*p as if in infinite + * precise arithmetic, where [x/p] is the (infinite bit) + * integer nearest x/p (in half way case choose the even one). + * Method : + * Based on fmod() return x-[x/p]chopped*p exactlp. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double zero = 0.0; +#else +static double zero = 0.0; +#endif + + +#ifdef __STDC__ + double __ieee754_remainder(double x, double p) +#else + double __ieee754_remainder(x,p) + double x,p; +#endif +{ + __int32_t hx,hp; + __uint32_t sx,lx,lp; + double p_half; + + EXTRACT_WORDS(hx,lx,x); + EXTRACT_WORDS(hp,lp,p); + sx = hx&0x80000000; + hp &= 0x7fffffff; + hx &= 0x7fffffff; + + /* purge off exception values */ + if((hp|lp)==0) return (x*p)/(x*p); /* p = 0 */ + if((hx>=0x7ff00000)|| /* x not finite */ + ((hp>=0x7ff00000)&& /* p is NaN */ + (((hp-0x7ff00000)|lp)!=0))) + return (x*p)/(x*p); + + + if (hp<=0x7fdfffff) x = __ieee754_fmod(x,p+p); /* now x < 2p */ + if (((hx-hp)|(lx-lp))==0) return zero*x; + x = fabs(x); + p = fabs(p); + if (hp<0x00200000) { + if(x+x>p) { + x-=p; + if(x+x>=p) x -= p; + } + } else { + p_half = 0.5*p; + if(x>p_half) { + x-=p; + if(x>=p_half) x -= p; + } + } + GET_HIGH_WORD(hx,x); + SET_HIGH_WORD(x,hx^sx); + return x; +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_scalb.c b/libjava/java/lang/e_scalb.c new file mode 100644 index 00000000000..0bb924b43ee --- /dev/null +++ b/libjava/java/lang/e_scalb.c @@ -0,0 +1,55 @@ + +/* @(#)e_scalb.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __ieee754_scalb(x, fn) is provide for + * passing various standard test suite. One + * should use scalbn() instead. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef _SCALB_INT +#ifdef __STDC__ + double __ieee754_scalb(double x, int fn) +#else + double __ieee754_scalb(x,fn) + double x; int fn; +#endif +#else +#ifdef __STDC__ + double __ieee754_scalb(double x, double fn) +#else + double __ieee754_scalb(x,fn) + double x, fn; +#endif +#endif +{ +#ifdef _SCALB_INT + return scalbn(x,fn); +#else + if (isnan(x)||isnan(fn)) return x*fn; + if (!finite(fn)) { + if(fn>0.0) return x*fn; + else return x/(-fn); + } + if (rint(fn)!=fn) return (fn-fn)/(fn-fn); + if ( fn > 65000.0) return scalbn(x, 65000); + if (-fn > 65000.0) return scalbn(x,-65000); + return scalbn(x,(int)fn); +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/e_sqrt.c b/libjava/java/lang/e_sqrt.c new file mode 100644 index 00000000000..b56b1eedc94 --- /dev/null +++ b/libjava/java/lang/e_sqrt.c @@ -0,0 +1,452 @@ + +/* @(#)e_sqrt.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __ieee754_sqrt(x) + * Return correctly rounded sqrt. + * ------------------------------------------ + * | Use the hardware sqrt if you have one | + * ------------------------------------------ + * Method: + * Bit by bit method using integer arithmetic. (Slow, but portable) + * 1. Normalization + * Scale x to y in [1,4) with even powers of 2: + * find an integer k such that 1 <= (y=x*2^(2k)) < 4, then + * sqrt(x) = 2^k * sqrt(y) + * 2. Bit by bit computation + * Let q = sqrt(y) truncated to i bit after binary point (q = 1), + * i 0 + * i+1 2 + * s = 2*q , and y = 2 * ( y - q ). (1) + * i i i i + * + * To compute q from q , one checks whether + * i+1 i + * + * -(i+1) 2 + * (q + 2 ) <= y. (2) + * i + * -(i+1) + * If (2) is false, then q = q ; otherwise q = q + 2 . + * i+1 i i+1 i + * + * With some algebric manipulation, it is not difficult to see + * that (2) is equivalent to + * -(i+1) + * s + 2 <= y (3) + * i i + * + * The advantage of (3) is that s and y can be computed by + * i i + * the following recurrence formula: + * if (3) is false + * + * s = s , y = y ; (4) + * i+1 i i+1 i + * + * otherwise, + * -i -(i+1) + * s = s + 2 , y = y - s - 2 (5) + * i+1 i i+1 i i + * + * One may easily use induction to prove (4) and (5). + * Note. Since the left hand side of (3) contain only i+2 bits, + * it does not necessary to do a full (53-bit) comparison + * in (3). + * 3. Final rounding + * After generating the 53 bits result, we compute one more bit. + * Together with the remainder, we can decide whether the + * result is exact, bigger than 1/2ulp, or less than 1/2ulp + * (it will never equal to 1/2ulp). + * The rounding mode can be detected by checking whether + * huge + tiny is equal to huge, and whether huge - tiny is + * equal to huge for some floating point number "huge" and "tiny". + * + * Special cases: + * sqrt(+-0) = +-0 ... exact + * sqrt(inf) = inf + * sqrt(-ve) = NaN ... with invalid signal + * sqrt(NaN) = NaN ... with invalid signal for signaling NaN + * + * Other methods : see the appended file at the end of the program below. + *--------------- + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double one = 1.0, tiny=1.0e-300; +#else +static double one = 1.0, tiny=1.0e-300; +#endif + +#ifdef __STDC__ + double __ieee754_sqrt(double x) +#else + double __ieee754_sqrt(x) + double x; +#endif +{ + double z; + __int32_t sign = (int)0x80000000; + __uint32_t r,t1,s1,ix1,q1; + __int32_t ix0,s0,q,m,t,i; + + EXTRACT_WORDS(ix0,ix1,x); + + /* take care of Inf and NaN */ + if((ix0&0x7ff00000)==0x7ff00000) { + return x*x+x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf + sqrt(-inf)=sNaN */ + } + /* take care of zero */ + if(ix0<=0) { + if(((ix0&(~sign))|ix1)==0) return x;/* sqrt(+-0) = +-0 */ + else if(ix0<0) + return (x-x)/(x-x); /* sqrt(-ve) = sNaN */ + } + /* normalize x */ + m = (ix0>>20); + if(m==0) { /* subnormal x */ + while(ix0==0) { + m -= 21; + ix0 |= (ix1>>11); ix1 <<= 21; + } + for(i=0;(ix0&0x00100000)==0;i++) ix0<<=1; + m -= i-1; + ix0 |= (ix1>>(32-i)); + ix1 <<= i; + } + m -= 1023; /* unbias exponent */ + ix0 = (ix0&0x000fffff)|0x00100000; + if(m&1){ /* odd m, double x to make it even */ + ix0 += ix0 + ((ix1&sign)>>31); + ix1 += ix1; + } + m >>= 1; /* m = [m/2] */ + + /* generate sqrt(x) bit by bit */ + ix0 += ix0 + ((ix1&sign)>>31); + ix1 += ix1; + q = q1 = s0 = s1 = 0; /* [q,q1] = sqrt(x) */ + r = 0x00200000; /* r = moving bit from right to left */ + + while(r!=0) { + t = s0+r; + if(t<=ix0) { + s0 = t+r; + ix0 -= t; + q += r; + } + ix0 += ix0 + ((ix1&sign)>>31); + ix1 += ix1; + r>>=1; + } + + r = sign; + while(r!=0) { + t1 = s1+r; + t = s0; + if((t>31); + ix1 += ix1; + r>>=1; + } + + /* use floating add to find out rounding direction */ + if((ix0|ix1)!=0) { + z = one-tiny; /* trigger inexact flag */ + if (z>=one) { + z = one+tiny; + if (q1==(__uint32_t)0xffffffff) { q1=0; q += 1;} + else if (z>one) { + if (q1==(__uint32_t)0xfffffffe) q+=1; + q1+=2; + } else + q1 += (q1&1); + } + } + ix0 = (q>>1)+0x3fe00000; + ix1 = q1>>1; + if ((q&1)==1) ix1 |= sign; + ix0 += (m <<20); + INSERT_WORDS(z,ix0,ix1); + return z; +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ + +/* +Other methods (use floating-point arithmetic) +------------- +(This is a copy of a drafted paper by Prof W. Kahan +and K.C. Ng, written in May, 1986) + + Two algorithms are given here to implement sqrt(x) + (IEEE double precision arithmetic) in software. + Both supply sqrt(x) correctly rounded. The first algorithm (in + Section A) uses newton iterations and involves four divisions. + The second one uses reciproot iterations to avoid division, but + requires more multiplications. Both algorithms need the ability + to chop results of arithmetic operations instead of round them, + and the INEXACT flag to indicate when an arithmetic operation + is executed exactly with no roundoff error, all part of the + standard (IEEE 754-1985). The ability to perform shift, add, + subtract and logical AND operations upon 32-bit words is needed + too, though not part of the standard. + +A. sqrt(x) by Newton Iteration + + (1) Initial approximation + + Let x0 and x1 be the leading and the trailing 32-bit words of + a floating point number x (in IEEE double format) respectively + + 1 11 52 ...widths + ------------------------------------------------------ + x: |s| e | f | + ------------------------------------------------------ + msb lsb msb lsb ...order + + + ------------------------ ------------------------ + x0: |s| e | f1 | x1: | f2 | + ------------------------ ------------------------ + + By performing shifts and subtracts on x0 and x1 (both regarded + as integers), we obtain an 8-bit approximation of sqrt(x) as + follows. + + k := (x0>>1) + 0x1ff80000; + y0 := k - T1[31&(k>>15)]. ... y ~ sqrt(x) to 8 bits + Here k is a 32-bit integer and T1[] is an integer array containing + correction terms. Now magically the floating value of y (y's + leading 32-bit word is y0, the value of its trailing word is 0) + approximates sqrt(x) to almost 8-bit. + + Value of T1: + static int T1[32]= { + 0, 1024, 3062, 5746, 9193, 13348, 18162, 23592, + 29598, 36145, 43202, 50740, 58733, 67158, 75992, 85215, + 83599, 71378, 60428, 50647, 41945, 34246, 27478, 21581, + 16499, 12183, 8588, 5674, 3403, 1742, 661, 130,}; + + (2) Iterative refinement + + Apply Heron's rule three times to y, we have y approximates + sqrt(x) to within 1 ulp (Unit in the Last Place): + + y := (y+x/y)/2 ... almost 17 sig. bits + y := (y+x/y)/2 ... almost 35 sig. bits + y := y-(y-x/y)/2 ... within 1 ulp + + + Remark 1. + Another way to improve y to within 1 ulp is: + + y := (y+x/y) ... almost 17 sig. bits to 2*sqrt(x) + y := y - 0x00100006 ... almost 18 sig. bits to sqrt(x) + + 2 + (x-y )*y + y := y + 2* ---------- ...within 1 ulp + 2 + 3y + x + + + This formula has one division fewer than the one above; however, + it requires more multiplications and additions. Also x must be + scaled in advance to avoid spurious overflow in evaluating the + expression 3y*y+x. Hence it is not recommended uless division + is slow. If division is very slow, then one should use the + reciproot algorithm given in section B. + + (3) Final adjustment + + By twiddling y's last bit it is possible to force y to be + correctly rounded according to the prevailing rounding mode + as follows. Let r and i be copies of the rounding mode and + inexact flag before entering the square root program. Also we + use the expression y+-ulp for the next representable floating + numbers (up and down) of y. Note that y+-ulp = either fixed + point y+-1, or multiply y by nextafter(1,+-inf) in chopped + mode. + + I := FALSE; ... reset INEXACT flag I + R := RZ; ... set rounding mode to round-toward-zero + z := x/y; ... chopped quotient, possibly inexact + If(not I) then { ... if the quotient is exact + if(z=y) { + I := i; ... restore inexact flag + R := r; ... restore rounded mode + return sqrt(x):=y. + } else { + z := z - ulp; ... special rounding + } + } + i := TRUE; ... sqrt(x) is inexact + If (r=RN) then z=z+ulp ... rounded-to-nearest + If (r=RP) then { ... round-toward-+inf + y = y+ulp; z=z+ulp; + } + y := y+z; ... chopped sum + y0:=y0-0x00100000; ... y := y/2 is correctly rounded. + I := i; ... restore inexact flag + R := r; ... restore rounded mode + return sqrt(x):=y. + + (4) Special cases + + Square root of +inf, +-0, or NaN is itself; + Square root of a negative number is NaN with invalid signal. + + +B. sqrt(x) by Reciproot Iteration + + (1) Initial approximation + + Let x0 and x1 be the leading and the trailing 32-bit words of + a floating point number x (in IEEE double format) respectively + (see section A). By performing shifs and subtracts on x0 and y0, + we obtain a 7.8-bit approximation of 1/sqrt(x) as follows. + + k := 0x5fe80000 - (x0>>1); + y0:= k - T2[63&(k>>14)]. ... y ~ 1/sqrt(x) to 7.8 bits + + Here k is a 32-bit integer and T2[] is an integer array + containing correction terms. Now magically the floating + value of y (y's leading 32-bit word is y0, the value of + its trailing word y1 is set to zero) approximates 1/sqrt(x) + to almost 7.8-bit. + + Value of T2: + static int T2[64]= { + 0x1500, 0x2ef8, 0x4d67, 0x6b02, 0x87be, 0xa395, 0xbe7a, 0xd866, + 0xf14a, 0x1091b,0x11fcd,0x13552,0x14999,0x15c98,0x16e34,0x17e5f, + 0x18d03,0x19a01,0x1a545,0x1ae8a,0x1b5c4,0x1bb01,0x1bfde,0x1c28d, + 0x1c2de,0x1c0db,0x1ba73,0x1b11c,0x1a4b5,0x1953d,0x18266,0x16be0, + 0x1683e,0x179d8,0x18a4d,0x19992,0x1a789,0x1b445,0x1bf61,0x1c989, + 0x1d16d,0x1d77b,0x1dddf,0x1e2ad,0x1e5bf,0x1e6e8,0x1e654,0x1e3cd, + 0x1df2a,0x1d635,0x1cb16,0x1be2c,0x1ae4e,0x19bde,0x1868e,0x16e2e, + 0x1527f,0x1334a,0x11051,0xe951, 0xbe01, 0x8e0d, 0x5924, 0x1edd,}; + + (2) Iterative refinement + + Apply Reciproot iteration three times to y and multiply the + result by x to get an approximation z that matches sqrt(x) + to about 1 ulp. To be exact, we will have + -1ulp < sqrt(x)-z<1.0625ulp. + + ... set rounding mode to Round-to-nearest + y := y*(1.5-0.5*x*y*y) ... almost 15 sig. bits to 1/sqrt(x) + y := y*((1.5-2^-30)+0.5*x*y*y)... about 29 sig. bits to 1/sqrt(x) + ... special arrangement for better accuracy + z := x*y ... 29 bits to sqrt(x), with z*y<1 + z := z + 0.5*z*(1-z*y) ... about 1 ulp to sqrt(x) + + Remark 2. The constant 1.5-2^-30 is chosen to bias the error so that + (a) the term z*y in the final iteration is always less than 1; + (b) the error in the final result is biased upward so that + -1 ulp < sqrt(x) - z < 1.0625 ulp + instead of |sqrt(x)-z|<1.03125ulp. + + (3) Final adjustment + + By twiddling y's last bit it is possible to force y to be + correctly rounded according to the prevailing rounding mode + as follows. Let r and i be copies of the rounding mode and + inexact flag before entering the square root program. Also we + use the expression y+-ulp for the next representable floating + numbers (up and down) of y. Note that y+-ulp = either fixed + point y+-1, or multiply y by nextafter(1,+-inf) in chopped + mode. + + R := RZ; ... set rounding mode to round-toward-zero + switch(r) { + case RN: ... round-to-nearest + if(x<= z*(z-ulp)...chopped) z = z - ulp; else + if(x<= z*(z+ulp)...chopped) z = z; else z = z+ulp; + break; + case RZ:case RM: ... round-to-zero or round-to--inf + R:=RP; ... reset rounding mod to round-to-+inf + if(x=(z+ulp)*(z+ulp) ...rounded up) z = z+ulp; + break; + case RP: ... round-to-+inf + if(x>(z+ulp)*(z+ulp)...chopped) z = z+2*ulp; else + if(x>z*z ...chopped) z = z+ulp; + break; + } + + Remark 3. The above comparisons can be done in fixed point. For + example, to compare x and w=z*z chopped, it suffices to compare + x1 and w1 (the trailing parts of x and w), regarding them as + two's complement integers. + + ...Is z an exact square root? + To determine whether z is an exact square root of x, let z1 be the + trailing part of z, and also let x0 and x1 be the leading and + trailing parts of x. + + If ((z1&0x03ffffff)!=0) ... not exact if trailing 26 bits of z!=0 + I := 1; ... Raise Inexact flag: z is not exact + else { + j := 1 - [(x0>>20)&1] ... j = logb(x) mod 2 + k := z1 >> 26; ... get z's 25-th and 26-th + fraction bits + I := i or (k&j) or ((k&(j+j+1))!=(x1&3)); + } + R:= r ... restore rounded mode + return sqrt(x):=z. + + If multiplication is cheaper then the foregoing red tape, the + Inexact flag can be evaluated by + + I := i; + I := (z*z!=x) or I. + + Note that z*z can overwrite I; this value must be sensed if it is + True. + + Remark 4. If z*z = x exactly, then bit 25 to bit 0 of z1 must be + zero. + + -------------------- + z1: | f2 | + -------------------- + bit 31 bit 0 + + Further more, bit 27 and 26 of z1, bit 0 and 1 of x1, and the odd + or even of logb(x) have the following relations: + + ------------------------------------------------- + bit 27,26 of z1 bit 1,0 of x1 logb(x) + ------------------------------------------------- + 00 00 odd and even + 01 01 even + 10 10 odd + 10 00 even + 11 01 even + ------------------------------------------------- + + (4) Special cases (see (4) of Section A). + + */ diff --git a/libjava/java/lang/fdlibm.h b/libjava/java/lang/fdlibm.h new file mode 100644 index 00000000000..3f72070cf81 --- /dev/null +++ b/libjava/java/lang/fdlibm.h @@ -0,0 +1,343 @@ + +/* @(#)fdlibm.h 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +/* CYGNUS LOCAL: Include files. */ +#include "ieeefp.h" + +/* CYGNUS LOCAL: Default to XOPEN_MODE. */ +#define _XOPEN_MODE + +#ifdef __STDC__ +#define __P(p) p +#else +#define __P(p) () +#endif + +#define HUGE ((float)3.40282346638528860e+38) + +/* + * set X_TLOSS = pi*2**52, which is possibly defined in + * (one may replace the following line by "#include ") + */ + +#define X_TLOSS 1.41484755040568800000e+16 + +/* These typedefs are true for the targets running Java. */ + +#ifndef HAVE_INT32_DEFINED +typedef int __int32_t; +typedef unsigned int __uint32_t; +#endif + +#define _IEEE_LIBM + +/* + * ANSI/POSIX + */ +extern double acos __P((double)); +extern double asin __P((double)); +extern double atan __P((double)); +extern double atan2 __P((double, double)); +extern double cos __P((double)); +extern double sin __P((double)); +extern double tan __P((double)); + +extern double cosh __P((double)); +extern double sinh __P((double)); +extern double tanh __P((double)); + +extern double exp __P((double)); +extern double frexp __P((double, int *)); +extern double ldexp __P((double, int)); +extern double log __P((double)); +extern double log10 __P((double)); +extern double modf __P((double, double *)); + +extern double pow __P((double, double)); +extern double sqrt __P((double)); + +extern double ceil __P((double)); +extern double fabs __P((double)); +extern double floor __P((double)); +extern double fmod __P((double, double)); + +extern double erf __P((double)); +extern double erfc __P((double)); +extern double gamma __P((double)); +extern double hypot __P((double, double)); +extern int isnan __P((double)); +extern int finite __P((double)); +extern double j0 __P((double)); +extern double j1 __P((double)); +extern double jn __P((int, double)); +extern double lgamma __P((double)); +extern double y0 __P((double)); +extern double y1 __P((double)); +extern double yn __P((int, double)); + +extern double acosh __P((double)); +extern double asinh __P((double)); +extern double atanh __P((double)); +extern double cbrt __P((double)); +extern double logb __P((double)); +extern double nextafter __P((double, double)); +extern double remainder __P((double, double)); + +/* Functions that are not documented, and are not in . */ + +extern double logb __P((double)); +#ifdef _SCALB_INT +extern double scalb __P((double, int)); +#else +extern double scalb __P((double, double)); +#endif +extern double significand __P((double)); + +/* ieee style elementary functions */ +extern double __ieee754_sqrt __P((double)); +extern double __ieee754_acos __P((double)); +extern double __ieee754_acosh __P((double)); +extern double __ieee754_log __P((double)); +extern double __ieee754_atanh __P((double)); +extern double __ieee754_asin __P((double)); +extern double __ieee754_atan2 __P((double,double)); +extern double __ieee754_exp __P((double)); +extern double __ieee754_cosh __P((double)); +extern double __ieee754_fmod __P((double,double)); +extern double __ieee754_pow __P((double,double)); +extern double __ieee754_lgamma_r __P((double,int *)); +extern double __ieee754_gamma_r __P((double,int *)); +extern double __ieee754_log10 __P((double)); +extern double __ieee754_sinh __P((double)); +extern double __ieee754_hypot __P((double,double)); +extern double __ieee754_j0 __P((double)); +extern double __ieee754_j1 __P((double)); +extern double __ieee754_y0 __P((double)); +extern double __ieee754_y1 __P((double)); +extern double __ieee754_jn __P((int,double)); +extern double __ieee754_yn __P((int,double)); +extern double __ieee754_remainder __P((double,double)); +extern __int32_t __ieee754_rem_pio2 __P((double,double*)); +#ifdef _SCALB_INT +extern double __ieee754_scalb __P((double,int)); +#else +extern double __ieee754_scalb __P((double,double)); +#endif + +/* fdlibm kernel function */ +extern double __kernel_standard __P((double,double,int)); +extern double __kernel_sin __P((double,double,int)); +extern double __kernel_cos __P((double,double)); +extern double __kernel_tan __P((double,double,int)); +extern int __kernel_rem_pio2 __P((double*,double*,int,int,int,const __int32_t*)); + +/* Undocumented float functions. */ +extern float logbf __P((float)); +#ifdef _SCALB_INT +extern float scalbf __P((float, int)); +#else +extern float scalbf __P((float, float)); +#endif +extern float significandf __P((float)); + +/* + * Functions callable from C, intended to support IEEE arithmetic. + */ +extern double copysign __P((double, double)); +extern int ilogb __P((double)); +extern double rint __P((double)); +extern float rintf __P((float)); +extern double scalbn __P((double, int)); + +/* ieee style elementary float functions */ +extern float __ieee754_sqrtf __P((float)); +extern float __ieee754_acosf __P((float)); +extern float __ieee754_acoshf __P((float)); +extern float __ieee754_logf __P((float)); +extern float __ieee754_atanhf __P((float)); +extern float __ieee754_asinf __P((float)); +extern float __ieee754_atan2f __P((float,float)); +extern float __ieee754_expf __P((float)); +extern float __ieee754_coshf __P((float)); +extern float __ieee754_fmodf __P((float,float)); +extern float __ieee754_powf __P((float,float)); +extern float __ieee754_lgammaf_r __P((float,int *)); +extern float __ieee754_gammaf_r __P((float,int *)); +extern float __ieee754_log10f __P((float)); +extern float __ieee754_sinhf __P((float)); +extern float __ieee754_hypotf __P((float,float)); +extern float __ieee754_j0f __P((float)); +extern float __ieee754_j1f __P((float)); +extern float __ieee754_y0f __P((float)); +extern float __ieee754_y1f __P((float)); +extern float __ieee754_jnf __P((int,float)); +extern float __ieee754_ynf __P((int,float)); +extern float __ieee754_remainderf __P((float,float)); +extern __int32_t __ieee754_rem_pio2f __P((float,float*)); +#ifdef _SCALB_INT +extern float __ieee754_scalbf __P((float,int)); +#else +extern float __ieee754_scalbf __P((float,float)); +#endif + +/* float versions of fdlibm kernel functions */ +extern float __kernel_sinf __P((float,float,int)); +extern float __kernel_cosf __P((float,float)); +extern float __kernel_tanf __P((float,float,int)); +extern int __kernel_rem_pio2f __P((float*,float*,int,int,int,const __int32_t*)); + +/* The original code used statements like + n0 = ((*(int*)&one)>>29)^1; * index of high word * + ix0 = *(n0+(int*)&x); * high word of x * + ix1 = *((1-n0)+(int*)&x); * low word of x * + to dig two 32 bit words out of the 64 bit IEEE floating point + value. That is non-ANSI, and, moreover, the gcc instruction + scheduler gets it wrong. We instead use the following macros. + Unlike the original code, we determine the endianness at compile + time, not at run time; I don't see much benefit to selecting + endianness at run time. */ + +#ifndef __IEEE_BIG_ENDIAN +#ifndef __IEEE_LITTLE_ENDIAN + #error Must define endianness +#endif +#endif + +/* A union which permits us to convert between a double and two 32 bit + ints. */ + +#ifdef __IEEE_BIG_ENDIAN + +typedef union +{ + double value; + struct + { + __uint32_t msw; + __uint32_t lsw; + } parts; +} ieee_double_shape_type; + +#endif + +#ifdef __IEEE_LITTLE_ENDIAN + +typedef union +{ + double value; + struct + { + __uint32_t lsw; + __uint32_t msw; + } parts; +} ieee_double_shape_type; + +#endif + +/* Get two 32 bit ints from a double. */ + +#define EXTRACT_WORDS(ix0,ix1,d) \ +do { \ + ieee_double_shape_type ew_u; \ + ew_u.value = (d); \ + (ix0) = ew_u.parts.msw; \ + (ix1) = ew_u.parts.lsw; \ +} while (0) + +/* Get the more significant 32 bit int from a double. */ + +#define GET_HIGH_WORD(i,d) \ +do { \ + ieee_double_shape_type gh_u; \ + gh_u.value = (d); \ + (i) = gh_u.parts.msw; \ +} while (0) + +/* Get the less significant 32 bit int from a double. */ + +#define GET_LOW_WORD(i,d) \ +do { \ + ieee_double_shape_type gl_u; \ + gl_u.value = (d); \ + (i) = gl_u.parts.lsw; \ +} while (0) + +/* Set a double from two 32 bit ints. */ + +#define INSERT_WORDS(d,ix0,ix1) \ +do { \ + ieee_double_shape_type iw_u; \ + iw_u.parts.msw = (ix0); \ + iw_u.parts.lsw = (ix1); \ + (d) = iw_u.value; \ +} while (0) + +/* Set the more significant 32 bits of a double from an int. */ + +#define SET_HIGH_WORD(d,v) \ +do { \ + ieee_double_shape_type sh_u; \ + sh_u.value = (d); \ + sh_u.parts.msw = (v); \ + (d) = sh_u.value; \ +} while (0) + +/* Set the less significant 32 bits of a double from an int. */ + +#define SET_LOW_WORD(d,v) \ +do { \ + ieee_double_shape_type sl_u; \ + sl_u.value = (d); \ + sl_u.parts.lsw = (v); \ + (d) = sl_u.value; \ +} while (0) + +/* A union which permits us to convert between a float and a 32 bit + int. */ + +typedef union +{ + float value; + __uint32_t word; +} ieee_float_shape_type; + +/* Get a 32 bit int from a float. */ + +#define GET_FLOAT_WORD(i,d) \ +do { \ + ieee_float_shape_type gf_u; \ + gf_u.value = (d); \ + (i) = gf_u.word; \ +} while (0) + +/* Set a float from a 32 bit int. */ + +#define SET_FLOAT_WORD(d,i) \ +do { \ + ieee_float_shape_type sf_u; \ + sf_u.word = (i); \ + (d) = sf_u.value; \ +} while (0) + +#ifdef __cplusplus +} +#endif + diff --git a/libjava/java/lang/ieeefp.h b/libjava/java/lang/ieeefp.h new file mode 100644 index 00000000000..931bafb7d1a --- /dev/null +++ b/libjava/java/lang/ieeefp.h @@ -0,0 +1,103 @@ +#ifndef __IEEE_BIG_ENDIAN +#ifndef __IEEE_LITTLE_ENDIAN + +#ifdef __arm__ +/* ARM always has big-endian words. Within those words the byte ordering + appears to be big or little endian. Newlib doesn't seem to care about + the byte ordering within words. */ +#define __IEEE_BIG_ENDIAN +#endif + +#ifdef __hppa__ +#define __IEEE_BIG_ENDIAN +#endif + +#if defined (__sparc) || defined (__sparc__) +#define __IEEE_BIG_ENDIAN +#endif + +#if defined(__m68k__) || defined(__mc68000__) +#define __IEEE_BIG_ENDIAN +#endif + +#if defined (__H8300__) || defined (__H8300H__) +#define __IEEE_BIG_ENDIAN +#define __SMALL_BITFIELDS +#define _DOUBLE_IS_32BITS +#endif + +#ifdef __H8500__ +#define __IEEE_BIG_ENDIAN +#define __SMALL_BITFIELDS +#define _DOUBLE_IS_32BITS +#endif + +#ifdef __sh__ +#ifdef __LITTLE_ENDIAN__ +#define __IEEE_LITTLE_ENDIAN +#else +#define __IEEE_BIG_ENDIAN +#endif +#ifdef __SH3E__ +#define _DOUBLE_IS_32BITS +#endif +#endif + +#ifdef _AM29K +#define __IEEE_BIG_ENDIAN +#endif + +#ifdef __i386__ +#define __IEEE_LITTLE_ENDIAN +#endif + +#ifdef __i960__ +#define __IEEE_LITTLE_ENDIAN +#endif + +#ifdef __MIPSEL__ +#define __IEEE_LITTLE_ENDIAN +#endif +#ifdef __MIPSEB__ +#define __IEEE_BIG_ENDIAN +#endif + +/* necv70 was __IEEE_LITTLE_ENDIAN. */ + +#ifdef __W65__ +#define __IEEE_LITTLE_ENDIAN +#define __SMALL_BITFIELDS +#define _DOUBLE_IS_32BITS +#endif + +#if defined(__Z8001__) || defined(__Z8002__) +#define __IEEE_BIG_ENDIAN +#endif + +#ifdef __m88k__ +#define __IEEE_BIG_ENDIAN +#endif + +#ifdef __v800 +#define __IEEE_LITTLE_ENDIAN +#endif + +#ifdef __PPC__ +#if (defined(_BIG_ENDIAN) && _BIG_ENDIAN) || (defined(_AIX) && _AIX) +#define __IEEE_BIG_ENDIAN +#else +#if (defined(_LITTLE_ENDIAN) && _LITTLE_ENDIAN) || (defined(__sun__) && __sun__) || (defined(__WIN32__) && __WIN32__) +#define __IEEE_LITTLE_ENDIAN +#endif +#endif +#endif + +#ifndef __IEEE_BIG_ENDIAN +#ifndef __IEEE_LITTLE_ENDIAN +#error Endianess not declared!! +#endif /* not __IEEE_LITTLE_ENDIAN */ +#endif /* not __IEEE_BIG_ENDIAN */ + +#endif /* not __IEEE_LITTLE_ENDIAN */ +#endif /* not __IEEE_BIG_ENDIAN */ + diff --git a/libjava/java/lang/k_cos.c b/libjava/java/lang/k_cos.c new file mode 100644 index 00000000000..6c60c243856 --- /dev/null +++ b/libjava/java/lang/k_cos.c @@ -0,0 +1,96 @@ + +/* @(#)k_cos.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __kernel_cos( x, y ) + * kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * + * Algorithm + * 1. Since cos(-x) = cos(x), we need only to consider positive x. + * 2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0. + * 3. cos(x) is approximated by a polynomial of degree 14 on + * [0,pi/4] + * 4 14 + * cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x + * where the remez error is + * + * | 2 4 6 8 10 12 14 | -58 + * |cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x +C6*x )| <= 2 + * | | + * + * 4 6 8 10 12 14 + * 4. let r = C1*x +C2*x +C3*x +C4*x +C5*x +C6*x , then + * cos(x) = 1 - x*x/2 + r + * since cos(x+y) ~ cos(x) - sin(x)*y + * ~ cos(x) - x*y, + * a correction term is necessary in cos(x) and hence + * cos(x+y) = 1 - (x*x/2 - (r - x*y)) + * For better accuracy when x > 0.3, let qx = |x|/4 with + * the last 32 bits mask off, and if x > 0.78125, let qx = 0.28125. + * Then + * cos(x+y) = (1-qx) - ((x*x/2-qx) - (r-x*y)). + * Note that 1-qx and (x*x/2-qx) is EXACT here, and the + * magnitude of the latter is at least a quarter of x*x/2, + * thus, reducing the rounding error in the subtraction. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ +C1 = 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C */ +C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */ +C3 = 2.48015872894767294178e-05, /* 0x3EFA01A0, 0x19CB1590 */ +C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */ +C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */ +C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */ + +#ifdef __STDC__ + double __kernel_cos(double x, double y) +#else + double __kernel_cos(x, y) + double x,y; +#endif +{ + double a,hz,z,r,qx; + __int32_t ix; + GET_HIGH_WORD(ix,x); + ix &= 0x7fffffff; /* ix = |x|'s high word*/ + if(ix<0x3e400000) { /* if x < 2**27 */ + if(((int)x)==0) return one; /* generate inexact */ + } + z = x*x; + r = z*(C1+z*(C2+z*(C3+z*(C4+z*(C5+z*C6))))); + if(ix < 0x3FD33333) /* if |x| < 0.3 */ + return one - (0.5*z - (z*r - x*y)); + else { + if(ix > 0x3fe90000) { /* x > 0.78125 */ + qx = 0.28125; + } else { + INSERT_WORDS(qx,ix-0x00200000,0); /* x/4 */ + } + hz = 0.5*z-qx; + a = one-qx; + return a - (hz - (z*r-x*y)); + } +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/k_rem_pio2.c b/libjava/java/lang/k_rem_pio2.c new file mode 100644 index 00000000000..8569256686c --- /dev/null +++ b/libjava/java/lang/k_rem_pio2.c @@ -0,0 +1,320 @@ + +/* @(#)k_rem_pio2.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __kernel_rem_pio2(x,y,e0,nx,prec,ipio2) + * double x[],y[]; int e0,nx,prec; int ipio2[]; + * + * __kernel_rem_pio2 return the last three digits of N with + * y = x - N*pi/2 + * so that |y| < pi/2. + * + * The method is to compute the integer (mod 8) and fraction parts of + * (2/pi)*x without doing the full multiplication. In general we + * skip the part of the product that are known to be a huge integer ( + * more accurately, = 0 mod 8 ). Thus the number of operations are + * independent of the exponent of the input. + * + * (2/pi) is represented by an array of 24-bit integers in ipio2[]. + * + * Input parameters: + * x[] The input value (must be positive) is broken into nx + * pieces of 24-bit integers in double precision format. + * x[i] will be the i-th 24 bit of x. The scaled exponent + * of x[0] is given in input parameter e0 (i.e., x[0]*2^e0 + * match x's up to 24 bits. + * + * Example of breaking a double positive z into x[0]+x[1]+x[2]: + * e0 = ilogb(z)-23 + * z = scalbn(z,-e0) + * for i = 0,1,2 + * x[i] = floor(z) + * z = (z-x[i])*2**24 + * + * + * y[] ouput result in an array of double precision numbers. + * The dimension of y[] is: + * 24-bit precision 1 + * 53-bit precision 2 + * 64-bit precision 2 + * 113-bit precision 3 + * The actual value is the sum of them. Thus for 113-bit + * precison, one may have to do something like: + * + * long double t,w,r_head, r_tail; + * t = (long double)y[2] + (long double)y[1]; + * w = (long double)y[0]; + * r_head = t+w; + * r_tail = w - (r_head - t); + * + * e0 The exponent of x[0] + * + * nx dimension of x[] + * + * prec an integer indicating the precision: + * 0 24 bits (single) + * 1 53 bits (double) + * 2 64 bits (extended) + * 3 113 bits (quad) + * + * ipio2[] + * integer array, contains the (24*i)-th to (24*i+23)-th + * bit of 2/pi after binary point. The corresponding + * floating value is + * + * ipio2[i] * 2^(-24(i+1)). + * + * External function: + * double scalbn(), floor(); + * + * + * Here is the description of some local variables: + * + * jk jk+1 is the initial number of terms of ipio2[] needed + * in the computation. The recommended value is 2,3,4, + * 6 for single, double, extended,and quad. + * + * jz local integer variable indicating the number of + * terms of ipio2[] used. + * + * jx nx - 1 + * + * jv index for pointing to the suitable ipio2[] for the + * computation. In general, we want + * ( 2^e0*x[0] * ipio2[jv-1]*2^(-24jv) )/8 + * is an integer. Thus + * e0-3-24*jv >= 0 or (e0-3)/24 >= jv + * Hence jv = max(0,(e0-3)/24). + * + * jp jp+1 is the number of terms in PIo2[] needed, jp = jk. + * + * q[] double array with integral value, representing the + * 24-bits chunk of the product of x and 2/pi. + * + * q0 the corresponding exponent of q[0]. Note that the + * exponent for q[i] would be q0-24*i. + * + * PIo2[] double precision array, obtained by cutting pi/2 + * into 24 bits chunks. + * + * f[] ipio2[] in floating point + * + * iq[] integer array by breaking up q[] in 24-bits chunk. + * + * fq[] final product of x*(2/pi) in fq[0],..,fq[jk] + * + * ih integer. If >0 it indicates q[] is >= 0.5, hence + * it also indicates the *sign* of the result. + * + */ + + +/* + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const int init_jk[] = {2,3,4,6}; /* initial value for jk */ +#else +static int init_jk[] = {2,3,4,6}; +#endif + +#ifdef __STDC__ +static const double PIo2[] = { +#else +static double PIo2[] = { +#endif + 1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */ + 7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */ + 5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */ + 3.28200341580791294123e-22, /* 0x3B78CC51, 0x60000000 */ + 1.27065575308067607349e-29, /* 0x39F01B83, 0x80000000 */ + 1.22933308981111328932e-36, /* 0x387A2520, 0x40000000 */ + 2.73370053816464559624e-44, /* 0x36E38222, 0x80000000 */ + 2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */ +}; + +#ifdef __STDC__ +static const double +#else +static double +#endif +zero = 0.0, +one = 1.0, +two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */ +twon24 = 5.96046447753906250000e-08; /* 0x3E700000, 0x00000000 */ + +#ifdef __STDC__ + int __kernel_rem_pio2(double *x, double *y, int e0, int nx, int prec, const __int32_t *ipio2) +#else + int __kernel_rem_pio2(x,y,e0,nx,prec,ipio2) + double x[], y[]; int e0,nx,prec; __int32_t ipio2[]; +#endif +{ + __int32_t jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih; + double z,fw,f[20],fq[20],q[20]; + + /* initialize jk*/ + jk = init_jk[prec]; + jp = jk; + + /* determine jx,jv,q0, note that 3>q0 */ + jx = nx-1; + jv = (e0-3)/24; if(jv<0) jv=0; + q0 = e0-24*(jv+1); + + /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */ + j = jv-jx; m = jx+jk; + for(i=0;i<=m;i++,j++) f[i] = (j<0)? zero : (double) ipio2[j]; + + /* compute q[0],q[1],...q[jk] */ + for (i=0;i<=jk;i++) { + for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j]; q[i] = fw; + } + + jz = jk; +recompute: + /* distill q[] into iq[] reversingly */ + for(i=0,j=jz,z=q[jz];j>0;i++,j--) { + fw = (double)((__int32_t)(twon24* z)); + iq[i] = (__int32_t)(z-two24*fw); + z = q[j-1]+fw; + } + + /* compute n */ + z = scalbn(z,(int)q0); /* actual value of z */ + z -= 8.0*floor(z*0.125); /* trim off integer >= 8 */ + n = (__int32_t) z; + z -= (double)n; + ih = 0; + if(q0>0) { /* need iq[jz-1] to determine n */ + i = (iq[jz-1]>>(24-q0)); n += i; + iq[jz-1] -= i<<(24-q0); + ih = iq[jz-1]>>(23-q0); + } + else if(q0==0) ih = iq[jz-1]>>23; + else if(z>=0.5) ih=2; + + if(ih>0) { /* q > 0.5 */ + n += 1; carry = 0; + for(i=0;i0) { /* rare case: chance is 1 in 12 */ + switch(q0) { + case 1: + iq[jz-1] &= 0x7fffff; break; + case 2: + iq[jz-1] &= 0x3fffff; break; + } + } + if(ih==2) { + z = one - z; + if(carry!=0) z -= scalbn(one,(int)q0); + } + } + + /* check if recomputation is needed */ + if(z==zero) { + j = 0; + for (i=jz-1;i>=jk;i--) j |= iq[i]; + if(j==0) { /* need recomputation */ + for(k=1;iq[jk-k]==0;k++); /* k = no. of terms needed */ + + for(i=jz+1;i<=jz+k;i++) { /* add q[jz+1] to q[jz+k] */ + f[jx+i] = (double) ipio2[jv+i]; + for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j]; + q[i] = fw; + } + jz += k; + goto recompute; + } + } + + /* chop off zero terms */ + if(z==0.0) { + jz -= 1; q0 -= 24; + while(iq[jz]==0) { jz--; q0-=24;} + } else { /* break z into 24-bit if necessary */ + z = scalbn(z,-(int)q0); + if(z>=two24) { + fw = (double)((__int32_t)(twon24*z)); + iq[jz] = (__int32_t)(z-two24*fw); + jz += 1; q0 += 24; + iq[jz] = (__int32_t) fw; + } else iq[jz] = (__int32_t) z ; + } + + /* convert integer "bit" chunk to floating-point value */ + fw = scalbn(one,(int)q0); + for(i=jz;i>=0;i--) { + q[i] = fw*(double)iq[i]; fw*=twon24; + } + + /* compute PIo2[0,...,jp]*q[jz,...,0] */ + for(i=jz;i>=0;i--) { + for(fw=0.0,k=0;k<=jp&&k<=jz-i;k++) fw += PIo2[k]*q[i+k]; + fq[jz-i] = fw; + } + + /* compress fq[] into y[] */ + switch(prec) { + case 0: + fw = 0.0; + for (i=jz;i>=0;i--) fw += fq[i]; + y[0] = (ih==0)? fw: -fw; + break; + case 1: + case 2: + fw = 0.0; + for (i=jz;i>=0;i--) fw += fq[i]; + y[0] = (ih==0)? fw: -fw; + fw = fq[0]-fw; + for (i=1;i<=jz;i++) fw += fq[i]; + y[1] = (ih==0)? fw: -fw; + break; + case 3: /* painful */ + for (i=jz;i>0;i--) { + fw = fq[i-1]+fq[i]; + fq[i] += fq[i-1]-fw; + fq[i-1] = fw; + } + for (i=jz;i>1;i--) { + fw = fq[i-1]+fq[i]; + fq[i] += fq[i-1]-fw; + fq[i-1] = fw; + } + for (fw=0.0,i=jz;i>=2;i--) fw += fq[i]; + if(ih==0) { + y[0] = fq[0]; y[1] = fq[1]; y[2] = fw; + } else { + y[0] = -fq[0]; y[1] = -fq[1]; y[2] = -fw; + } + } + return n&7; +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/k_sin.c b/libjava/java/lang/k_sin.c new file mode 100644 index 00000000000..f119916dfbc --- /dev/null +++ b/libjava/java/lang/k_sin.c @@ -0,0 +1,79 @@ + +/* @(#)k_sin.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __kernel_sin( x, y, iy) + * kernel sin function on [-pi/4, pi/4], pi/4 ~ 0.7854 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * Input iy indicates whether y is 0. (if iy=0, y assume to be 0). + * + * Algorithm + * 1. Since sin(-x) = -sin(x), we need only to consider positive x. + * 2. if x < 2^-27 (hx<0x3e400000 0), return x with inexact if x!=0. + * 3. sin(x) is approximated by a polynomial of degree 13 on + * [0,pi/4] + * 3 13 + * sin(x) ~ x + S1*x + ... + S6*x + * where + * + * |sin(x) 2 4 6 8 10 12 | -58 + * |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x +S6*x )| <= 2 + * | x | + * + * 4. sin(x+y) = sin(x) + sin'(x')*y + * ~ sin(x) + (1-x*x/2)*y + * For better accuracy, let + * 3 2 2 2 2 + * r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6)))) + * then 3 2 + * sin(x) = x + (S1*x + (x *(r-y/2)+y)) + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */ +S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 */ +S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */ +S3 = -1.98412698298579493134e-04, /* 0xBF2A01A0, 0x19C161D5 */ +S4 = 2.75573137070700676789e-06, /* 0x3EC71DE3, 0x57B1FE7D */ +S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */ +S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */ + +#ifdef __STDC__ + double __kernel_sin(double x, double y, int iy) +#else + double __kernel_sin(x, y, iy) + double x,y; int iy; /* iy=0 if y is zero */ +#endif +{ + double z,r,v; + __int32_t ix; + GET_HIGH_WORD(ix,x); + ix &= 0x7fffffff; /* high word of x */ + if(ix<0x3e400000) /* |x| < 2**-27 */ + {if((int)x==0) return x;} /* generate inexact */ + z = x*x; + v = z*x; + r = S2+z*(S3+z*(S4+z*(S5+z*S6))); + if(iy==0) return x+v*(S1+z*r); + else return x-((z*(half*y-v*r)-y)-v*S1); +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/k_tan.c b/libjava/java/lang/k_tan.c new file mode 100644 index 00000000000..9f5b307600c --- /dev/null +++ b/libjava/java/lang/k_tan.c @@ -0,0 +1,132 @@ + +/* @(#)k_tan.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __kernel_tan( x, y, k ) + * kernel tan function on [-pi/4, pi/4], pi/4 ~ 0.7854 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * Input k indicates whether tan (if k=1) or + * -1/tan (if k= -1) is returned. + * + * Algorithm + * 1. Since tan(-x) = -tan(x), we need only to consider positive x. + * 2. if x < 2^-28 (hx<0x3e300000 0), return x with inexact if x!=0. + * 3. tan(x) is approximated by a odd polynomial of degree 27 on + * [0,0.67434] + * 3 27 + * tan(x) ~ x + T1*x + ... + T13*x + * where + * + * |tan(x) 2 4 26 | -59.2 + * |----- - (1+T1*x +T2*x +.... +T13*x )| <= 2 + * | x | + * + * Note: tan(x+y) = tan(x) + tan'(x)*y + * ~ tan(x) + (1+x*x)*y + * Therefore, for better accuracy in computing tan(x+y), let + * 3 2 2 2 2 + * r = x *(T2+x *(T3+x *(...+x *(T12+x *T13)))) + * then + * 3 2 + * tan(x+y) = x + (T1*x + (x *(r+y)+y)) + * + * 4. For x in [0.67434,pi/4], let y = pi/4 - x, then + * tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y)) + * = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y))) + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ +pio4 = 7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */ +pio4lo= 3.06161699786838301793e-17, /* 0x3C81A626, 0x33145C07 */ +T[] = { + 3.33333333333334091986e-01, /* 0x3FD55555, 0x55555563 */ + 1.33333333333201242699e-01, /* 0x3FC11111, 0x1110FE7A */ + 5.39682539762260521377e-02, /* 0x3FABA1BA, 0x1BB341FE */ + 2.18694882948595424599e-02, /* 0x3F9664F4, 0x8406D637 */ + 8.86323982359930005737e-03, /* 0x3F8226E3, 0xE96E8493 */ + 3.59207910759131235356e-03, /* 0x3F6D6D22, 0xC9560328 */ + 1.45620945432529025516e-03, /* 0x3F57DBC8, 0xFEE08315 */ + 5.88041240820264096874e-04, /* 0x3F4344D8, 0xF2F26501 */ + 2.46463134818469906812e-04, /* 0x3F3026F7, 0x1A8D1068 */ + 7.81794442939557092300e-05, /* 0x3F147E88, 0xA03792A6 */ + 7.14072491382608190305e-05, /* 0x3F12B80F, 0x32F0A7E9 */ + -1.85586374855275456654e-05, /* 0xBEF375CB, 0xDB605373 */ + 2.59073051863633712884e-05, /* 0x3EFB2A70, 0x74BF7AD4 */ +}; + +#ifdef __STDC__ + double __kernel_tan(double x, double y, int iy) +#else + double __kernel_tan(x, y, iy) + double x,y; int iy; +#endif +{ + double z,r,v,w,s; + __int32_t ix,hx; + GET_HIGH_WORD(hx,x); + ix = hx&0x7fffffff; /* high word of |x| */ + if(ix<0x3e300000) /* x < 2**-28 */ + {if((int)x==0) { /* generate inexact */ + __uint32_t low; + GET_LOW_WORD(low,x); + if(((ix|low)|(iy+1))==0) return one/fabs(x); + else return (iy==1)? x: -one/x; + } + } + if(ix>=0x3FE59428) { /* |x|>=0.6744 */ + if(hx<0) {x = -x; y = -y;} + z = pio4-x; + w = pio4lo-y; + x = z+w; y = 0.0; + } + z = x*x; + w = z*z; + /* Break x^5*(T[1]+x^2*T[2]+...) into + * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) + + * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12])) + */ + r = T[1]+w*(T[3]+w*(T[5]+w*(T[7]+w*(T[9]+w*T[11])))); + v = z*(T[2]+w*(T[4]+w*(T[6]+w*(T[8]+w*(T[10]+w*T[12]))))); + s = z*x; + r = y + z*(s*(r+v)+y); + r += T[0]*s; + w = x+r; + if(ix>=0x3FE59428) { + v = (double)iy; + return (double)(1-((hx>>30)&2))*(v-2.0*(x-(w*w/(w+v)-r))); + } + if(iy==1) return w; + else { /* if allow error up to 2 ulp, + simply return -1.0/(x+r) here */ + /* compute -1.0/(x+r) accurately */ + double a,t; + z = w; + SET_LOW_WORD(z,0); + v = r-(z - x); /* z+v = r+x */ + t = a = -1.0/w; /* a = -1.0/w */ + SET_LOW_WORD(t,0); + s = 1.0+t*z; + return t+a*(s+t*v); + } +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/mprec.c b/libjava/java/lang/mprec.c new file mode 100644 index 00000000000..12dd5d2617a --- /dev/null +++ b/libjava/java/lang/mprec.c @@ -0,0 +1,958 @@ +/**************************************************************** + * + * The author of this software is David M. Gay. + * + * Copyright (c) 1991 by AT&T. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose without fee is hereby granted, provided that this entire notice + * is included in all copies of any software which is or includes a copy + * or modification of this software and in all copies of the supporting + * documentation for such software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY + * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. + * + ***************************************************************/ + +/* Please send bug reports to + David M. Gay + AT&T Bell Laboratories, Room 2C-463 + 600 Mountain Avenue + Murray Hill, NJ 07974-2070 + U.S.A. + dmg@research.att.com or research!dmg + */ + +/* strtod for IEEE-, VAX-, and IBM-arithmetic machines. + * + * This strtod returns a nearest machine number to the input decimal + * string (or sets errno to ERANGE). With IEEE arithmetic, ties are + * broken by the IEEE round-even rule. Otherwise ties are broken by + * biased rounding (add half and chop). + * + * Inspired loosely by William D. Clinger's paper "How to Read Floating + * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101]. + * + * Modifications: + * + * 1. We only require IEEE, IBM, or VAX double-precision + * arithmetic (not IEEE double-extended). + * 2. We get by with floating-point arithmetic in a case that + * Clinger missed -- when we're computing d * 10^n + * for a small integer d and the integer n is not too + * much larger than 22 (the maximum integer k for which + * we can represent 10^k exactly), we may be able to + * compute (d*10^k) * 10^(e-k) with just one roundoff. + * 3. Rather than a bit-at-a-time adjustment of the binary + * result in the hard case, we use floating-point + * arithmetic to determine the adjustment to within + * one bit; only in really hard cases do we need to + * compute a second residual. + * 4. Because of 3., we don't need a large table of powers of 10 + * for ten-to-e (just some small tables, e.g. of 10^k + * for 0 <= k <= 22). + */ + +/* + * #define IEEE_8087 for IEEE-arithmetic machines where the least + * significant byte has the lowest address. + * #define IEEE_MC68k for IEEE-arithmetic machines where the most + * significant byte has the lowest address. + * #define Sudden_Underflow for IEEE-format machines without gradual + * underflow (i.e., that flush to zero on underflow). + * #define IBM for IBM mainframe-style floating-point arithmetic. + * #define VAX for VAX-style floating-point arithmetic. + * #define Unsigned_Shifts if >> does treats its left operand as unsigned. + * #define No_leftright to omit left-right logic in fast floating-point + * computation of dtoa. + * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3. + * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines + * that use extended-precision instructions to compute rounded + * products and quotients) with IBM. + * #define ROUND_BIASED for IEEE-format with biased rounding. + * #define Inaccurate_Divide for IEEE-format with correctly rounded + * products but inaccurate quotients, e.g., for Intel i860. + * #define Just_16 to store 16 bits per 32-bit long when doing high-precision + * integer arithmetic. Whether this speeds things up or slows things + * down depends on the machine and the number being converted. + */ + +#include +#include +#include +#include "mprec.h" + +/* reent.c knows this value */ +#define _Kmax 15 +#include + +_Jv_Bigint * +_DEFUN (Balloc, (ptr, k), struct _Jv_reent *ptr _AND int k) +{ + _Jv_Bigint *rv = NULL; + + int i = 0; + int j = 1; + + JvAssert ((1 << k) < MAX_BIGNUM_WDS); + + while ((ptr->_allocation_map & j) && i < MAX_BIGNUMS) + i++, j <<= 1; + + JvAssert (i < MAX_BIGNUMS); + + if (i >= MAX_BIGNUMS) + return NULL; + + ptr->_allocation_map |= j; + rv = &ptr->_freelist[i]; + + rv->_k = k; + rv->_maxwds = 32; + + return rv; +} + + +void +_DEFUN (Bfree, (ptr, v), struct _Jv_reent *ptr _AND _Jv_Bigint * v) +{ + long i; + + i = v - ptr->_freelist; + + JvAssert (i >= 0 && i < MAX_BIGNUMS); + + if (i >= 0 && i < MAX_BIGNUMS) + ptr->_allocation_map &= ~ (1 << i); +} + + +_Jv_Bigint * +_DEFUN (multadd, (ptr, b, m, a), + struct _Jv_reent *ptr _AND + _Jv_Bigint * b _AND + int m _AND + int a) +{ + int i, wds; + unsigned long *x, y; +#ifdef Pack_32 + unsigned long xi, z; +#endif + _Jv_Bigint *b1; + + wds = b->_wds; + x = b->_x; + i = 0; + do + { +#ifdef Pack_32 + xi = *x; + y = (xi & 0xffff) * m + a; + z = (xi >> 16) * m + (y >> 16); + a = (int) (z >> 16); + *x++ = (z << 16) + (y & 0xffff); +#else + y = *x * m + a; + a = (int) (y >> 16); + *x++ = y & 0xffff; +#endif + } + while (++i < wds); + if (a) + { + if (wds >= b->_maxwds) + { + b1 = Balloc (ptr, b->_k + 1); + Bcopy (b1, b); + Bfree (ptr, b); + b = b1; + } + b->_x[wds++] = a; + b->_wds = wds; + } + return b; +} + +_Jv_Bigint * +_DEFUN (s2b, (ptr, s, nd0, nd, y9), + struct _Jv_reent * ptr _AND + _CONST char *s _AND + int nd0 _AND + int nd _AND + unsigned long y9) +{ + _Jv_Bigint *b; + int i, k; + long x, y; + + x = (nd + 8) / 9; + for (k = 0, y = 1; x > y; y <<= 1, k++); +#ifdef Pack_32 + b = Balloc (ptr, k); + b->_x[0] = y9; + b->_wds = 1; +#else + b = Balloc (ptr, k + 1); + b->_x[0] = y9 & 0xffff; + b->_wds = (b->_x[1] = y9 >> 16) ? 2 : 1; +#endif + + i = 9; + if (9 < nd0) + { + s += 9; + do + b = multadd (ptr, b, 10, *s++ - '0'); + while (++i < nd0); + s++; + } + else + s += 10; + for (; i < nd; i++) + b = multadd (ptr, b, 10, *s++ - '0'); + return b; +} + +int +_DEFUN (hi0bits, + (x), register unsigned long x) +{ + register int k = 0; + + if (!(x & 0xffff0000)) + { + k = 16; + x <<= 16; + } + if (!(x & 0xff000000)) + { + k += 8; + x <<= 8; + } + if (!(x & 0xf0000000)) + { + k += 4; + x <<= 4; + } + if (!(x & 0xc0000000)) + { + k += 2; + x <<= 2; + } + if (!(x & 0x80000000)) + { + k++; + if (!(x & 0x40000000)) + return 32; + } + return k; +} + +int +_DEFUN (lo0bits, (y), unsigned long *y) +{ + register int k; + register unsigned long x = *y; + + if (x & 7) + { + if (x & 1) + return 0; + if (x & 2) + { + *y = x >> 1; + return 1; + } + *y = x >> 2; + return 2; + } + k = 0; + if (!(x & 0xffff)) + { + k = 16; + x >>= 16; + } + if (!(x & 0xff)) + { + k += 8; + x >>= 8; + } + if (!(x & 0xf)) + { + k += 4; + x >>= 4; + } + if (!(x & 0x3)) + { + k += 2; + x >>= 2; + } + if (!(x & 1)) + { + k++; + x >>= 1; + if (!x & 1) + return 32; + } + *y = x; + return k; +} + +_Jv_Bigint * +_DEFUN (i2b, (ptr, i), struct _Jv_reent * ptr _AND int i) +{ + _Jv_Bigint *b; + + b = Balloc (ptr, 1); + b->_x[0] = i; + b->_wds = 1; + return b; +} + +_Jv_Bigint * +_DEFUN (mult, (ptr, a, b), struct _Jv_reent * ptr _AND _Jv_Bigint * a _AND _Jv_Bigint * b) +{ + _Jv_Bigint *c; + int k, wa, wb, wc; + unsigned long carry, y, z; + unsigned long *x, *xa, *xae, *xb, *xbe, *xc, *xc0; +#ifdef Pack_32 + unsigned long z2; +#endif + + if (a->_wds < b->_wds) + { + c = a; + a = b; + b = c; + } + k = a->_k; + wa = a->_wds; + wb = b->_wds; + wc = wa + wb; + if (wc > a->_maxwds) + k++; + c = Balloc (ptr, k); + for (x = c->_x, xa = x + wc; x < xa; x++) + *x = 0; + xa = a->_x; + xae = xa + wa; + xb = b->_x; + xbe = xb + wb; + xc0 = c->_x; +#ifdef Pack_32 + for (; xb < xbe; xb++, xc0++) + { + if ((y = *xb & 0xffff)) + { + x = xa; + xc = xc0; + carry = 0; + do + { + z = (*x & 0xffff) * y + (*xc & 0xffff) + carry; + carry = z >> 16; + z2 = (*x++ >> 16) * y + (*xc >> 16) + carry; + carry = z2 >> 16; + Storeinc (xc, z2, z); + } + while (x < xae); + *xc = carry; + } + if ((y = *xb >> 16)) + { + x = xa; + xc = xc0; + carry = 0; + z2 = *xc; + do + { + z = (*x & 0xffff) * y + (*xc >> 16) + carry; + carry = z >> 16; + Storeinc (xc, z, z2); + z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry; + carry = z2 >> 16; + } + while (x < xae); + *xc = z2; + } + } +#else + for (; xb < xbe; xc0++) + { + if (y = *xb++) + { + x = xa; + xc = xc0; + carry = 0; + do + { + z = *x++ * y + *xc + carry; + carry = z >> 16; + *xc++ = z & 0xffff; + } + while (x < xae); + *xc = carry; + } + } +#endif + for (xc0 = c->_x, xc = xc0 + wc; wc > 0 && !*--xc; --wc); + c->_wds = wc; + return c; +} + +_Jv_Bigint * +_DEFUN (pow5mult, + (ptr, b, k), struct _Jv_reent * ptr _AND _Jv_Bigint * b _AND int k) +{ + _Jv_Bigint *b1, *p5, *p51; + int i; + static _CONST int p05[3] = {5, 25, 125}; + + if ((i = k & 3)) + b = multadd (ptr, b, p05[i - 1], 0); + + if (!(k >>= 2)) + return b; + if (!(p5 = ptr->_p5s)) + { + /* first time */ + p5 = ptr->_p5s = i2b (ptr, 625); + p5->_next = 0; + } + for (;;) + { + if (k & 1) + { + b1 = mult (ptr, b, p5); + Bfree (ptr, b); + b = b1; + } + if (!(k >>= 1)) + break; + if (!(p51 = p5->_next)) + { + p51 = p5->_next = mult (ptr, p5, p5); + p51->_next = 0; + } + p5 = p51; + } + return b; +} + +_Jv_Bigint * +_DEFUN (lshift, (ptr, b, k), struct _Jv_reent * ptr _AND _Jv_Bigint * b _AND int k) +{ + int i, k1, n, n1; + _Jv_Bigint *b1; + unsigned long *x, *x1, *xe, z; + +#ifdef Pack_32 + n = k >> 5; +#else + n = k >> 4; +#endif + k1 = b->_k; + n1 = n + b->_wds + 1; + for (i = b->_maxwds; n1 > i; i <<= 1) + k1++; + b1 = Balloc (ptr, k1); + x1 = b1->_x; + for (i = 0; i < n; i++) + *x1++ = 0; + x = b->_x; + xe = x + b->_wds; +#ifdef Pack_32 + if (k &= 0x1f) + { + k1 = 32 - k; + z = 0; + do + { + *x1++ = *x << k | z; + z = *x++ >> k1; + } + while (x < xe); + if ((*x1 = z)) + ++n1; + } +#else + if (k &= 0xf) + { + k1 = 16 - k; + z = 0; + do + { + *x1++ = *x << k & 0xffff | z; + z = *x++ >> k1; + } + while (x < xe); + if (*x1 = z) + ++n1; + } +#endif + else + do + *x1++ = *x++; + while (x < xe); + b1->_wds = n1 - 1; + Bfree (ptr, b); + return b1; +} + +int +_DEFUN (cmp, (a, b), _Jv_Bigint * a _AND _Jv_Bigint * b) +{ + unsigned long *xa, *xa0, *xb, *xb0; + int i, j; + + i = a->_wds; + j = b->_wds; +#ifdef DEBUG + if (i > 1 && !a->_x[i - 1]) + Bug ("cmp called with a->_x[a->_wds-1] == 0"); + if (j > 1 && !b->_x[j - 1]) + Bug ("cmp called with b->_x[b->_wds-1] == 0"); +#endif + if (i -= j) + return i; + xa0 = a->_x; + xa = xa0 + j; + xb0 = b->_x; + xb = xb0 + j; + for (;;) + { + if (*--xa != *--xb) + return *xa < *xb ? -1 : 1; + if (xa <= xa0) + break; + } + return 0; +} + +_Jv_Bigint * +_DEFUN (diff, (ptr, a, b), struct _Jv_reent * ptr _AND + _Jv_Bigint * a _AND _Jv_Bigint * b) +{ + _Jv_Bigint *c; + int i, wa, wb; + long borrow, y; /* We need signed shifts here. */ + unsigned long *xa, *xae, *xb, *xbe, *xc; +#ifdef Pack_32 + long z; +#endif + + i = cmp (a, b); + if (!i) + { + c = Balloc (ptr, 0); + c->_wds = 1; + c->_x[0] = 0; + return c; + } + if (i < 0) + { + c = a; + a = b; + b = c; + i = 1; + } + else + i = 0; + c = Balloc (ptr, a->_k); + c->_sign = i; + wa = a->_wds; + xa = a->_x; + xae = xa + wa; + wb = b->_wds; + xb = b->_x; + xbe = xb + wb; + xc = c->_x; + borrow = 0; +#ifdef Pack_32 + do + { + y = (*xa & 0xffff) - (*xb & 0xffff) + borrow; + borrow = y >> 16; + Sign_Extend (borrow, y); + z = (*xa++ >> 16) - (*xb++ >> 16) + borrow; + borrow = z >> 16; + Sign_Extend (borrow, z); + Storeinc (xc, z, y); + } + while (xb < xbe); + while (xa < xae) + { + y = (*xa & 0xffff) + borrow; + borrow = y >> 16; + Sign_Extend (borrow, y); + z = (*xa++ >> 16) + borrow; + borrow = z >> 16; + Sign_Extend (borrow, z); + Storeinc (xc, z, y); + } +#else + do + { + y = *xa++ - *xb++ + borrow; + borrow = y >> 16; + Sign_Extend (borrow, y); + *xc++ = y & 0xffff; + } + while (xb < xbe); + while (xa < xae) + { + y = *xa++ + borrow; + borrow = y >> 16; + Sign_Extend (borrow, y); + *xc++ = y & 0xffff; + } +#endif + while (!*--xc) + wa--; + c->_wds = wa; + return c; +} + +double +_DEFUN (ulp, (_x), double _x) +{ + union double_union x, a; + register long L; + + x.d = _x; + + L = (word0 (x) & Exp_mask) - (P - 1) * Exp_msk1; +#ifndef Sudden_Underflow + if (L > 0) + { +#endif +#ifdef IBM + L |= Exp_msk1 >> 4; +#endif + word0 (a) = L; +#ifndef _DOUBLE_IS_32BITS + word1 (a) = 0; +#endif + +#ifndef Sudden_Underflow + } + else + { + L = -L >> Exp_shift; + if (L < Exp_shift) + { + word0 (a) = 0x80000 >> L; +#ifndef _DOUBLE_IS_32BITS + word1 (a) = 0; +#endif + } + else + { + word0 (a) = 0; + L -= Exp_shift; +#ifndef _DOUBLE_IS_32BITS + word1 (a) = L >= 31 ? 1 : 1 << (31 - L); +#endif + } + } +#endif + return a.d; +} + +double +_DEFUN (b2d, (a, e), + _Jv_Bigint * a _AND int *e) +{ + unsigned long *xa, *xa0, w, y, z; + int k; + union double_union d; +#ifdef VAX + unsigned long d0, d1; +#else +#define d0 word0(d) +#define d1 word1(d) +#endif + + xa0 = a->_x; + xa = xa0 + a->_wds; + y = *--xa; +#ifdef DEBUG + if (!y) + Bug ("zero y in b2d"); +#endif + k = hi0bits (y); + *e = 32 - k; +#ifdef Pack_32 + if (k < Ebits) + { + d0 = Exp_1 | y >> (Ebits - k); + w = xa > xa0 ? *--xa : 0; +#ifndef _DOUBLE_IS_32BITS + d1 = y << (32 - Ebits + k) | w >> (Ebits - k); +#endif + goto ret_d; + } + z = xa > xa0 ? *--xa : 0; + if (k -= Ebits) + { + d0 = Exp_1 | y << k | z >> (32 - k); + y = xa > xa0 ? *--xa : 0; +#ifndef _DOUBLE_IS_32BITS + d1 = z << k | y >> (32 - k); +#endif + } + else + { + d0 = Exp_1 | y; +#ifndef _DOUBLE_IS_32BITS + d1 = z; +#endif + } +#else + if (k < Ebits + 16) + { + z = xa > xa0 ? *--xa : 0; + d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k; + w = xa > xa0 ? *--xa : 0; + y = xa > xa0 ? *--xa : 0; + d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k; + goto ret_d; + } + z = xa > xa0 ? *--xa : 0; + w = xa > xa0 ? *--xa : 0; + k -= Ebits + 16; + d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k; + y = xa > xa0 ? *--xa : 0; + d1 = w << k + 16 | y << k; +#endif +ret_d: +#ifdef VAX + word0 (d) = d0 >> 16 | d0 << 16; + word1 (d) = d1 >> 16 | d1 << 16; +#else +#undef d0 +#undef d1 +#endif + return d.d; +} + +_Jv_Bigint * +_DEFUN (d2b, + (ptr, _d, e, bits), + struct _Jv_reent * ptr _AND + double _d _AND + int *e _AND + int *bits) + +{ + union double_union d; + _Jv_Bigint *b; + int de, i, k; + unsigned long *x, y, z; +#ifdef VAX + unsigned long d0, d1; + d.d = _d; + d0 = word0 (d) >> 16 | word0 (d) << 16; + d1 = word1 (d) >> 16 | word1 (d) << 16; +#else +#define d0 word0(d) +#define d1 word1(d) + d.d = _d; +#endif + +#ifdef Pack_32 + b = Balloc (ptr, 1); +#else + b = Balloc (ptr, 2); +#endif + x = b->_x; + + z = d0 & Frac_mask; + d0 &= 0x7fffffff; /* clear sign bit, which we ignore */ +#ifdef Sudden_Underflow + de = (int) (d0 >> Exp_shift); +#ifndef IBM + z |= Exp_msk11; +#endif +#else + if ((de = (int) (d0 >> Exp_shift))) + z |= Exp_msk1; +#endif +#ifdef Pack_32 +#ifndef _DOUBLE_IS_32BITS + if ((y = d1)) + { + if ((k = lo0bits (&y))) + { + x[0] = y | z << (32 - k); + z >>= k; + } + else + x[0] = y; + i = b->_wds = (x[1] = z) ? 2 : 1; + } + else +#endif + { +#ifdef DEBUG + if (!z) + Bug ("Zero passed to d2b"); +#endif + k = lo0bits (&z); + x[0] = z; + i = b->_wds = 1; +#ifndef _DOUBLE_IS_32BITS + k += 32; +#endif + } +#else + if (y = d1) + { + if (k = lo0bits (&y)) + if (k >= 16) + { + x[0] = y | z << 32 - k & 0xffff; + x[1] = z >> k - 16 & 0xffff; + x[2] = z >> k; + i = 2; + } + else + { + x[0] = y & 0xffff; + x[1] = y >> 16 | z << 16 - k & 0xffff; + x[2] = z >> k & 0xffff; + x[3] = z >> k + 16; + i = 3; + } + else + { + x[0] = y & 0xffff; + x[1] = y >> 16; + x[2] = z & 0xffff; + x[3] = z >> 16; + i = 3; + } + } + else + { +#ifdef DEBUG + if (!z) + Bug ("Zero passed to d2b"); +#endif + k = lo0bits (&z); + if (k >= 16) + { + x[0] = z; + i = 0; + } + else + { + x[0] = z & 0xffff; + x[1] = z >> 16; + i = 1; + } + k += 32; + } + while (!x[i]) + --i; + b->_wds = i + 1; +#endif +#ifndef Sudden_Underflow + if (de) + { +#endif +#ifdef IBM + *e = (de - Bias - (P - 1) << 2) + k; + *bits = 4 * P + 8 - k - hi0bits (word0 (d) & Frac_mask); +#else + *e = de - Bias - (P - 1) + k; + *bits = P - k; +#endif +#ifndef Sudden_Underflow + } + else + { + *e = de - Bias - (P - 1) + 1 + k; +#ifdef Pack_32 + *bits = 32 * i - hi0bits (x[i - 1]); +#else + *bits = (i + 2) * 16 - hi0bits (x[i]); +#endif + } +#endif + return b; +} +#undef d0 +#undef d1 + +double +_DEFUN (ratio, (a, b), _Jv_Bigint * a _AND _Jv_Bigint * b) + +{ + union double_union da, db; + int k, ka, kb; + + da.d = b2d (a, &ka); + db.d = b2d (b, &kb); +#ifdef Pack_32 + k = ka - kb + 32 * (a->_wds - b->_wds); +#else + k = ka - kb + 16 * (a->_wds - b->_wds); +#endif +#ifdef IBM + if (k > 0) + { + word0 (da) += (k >> 2) * Exp_msk1; + if (k &= 3) + da.d *= 1 << k; + } + else + { + k = -k; + word0 (db) += (k >> 2) * Exp_msk1; + if (k &= 3) + db.d *= 1 << k; + } +#else + if (k > 0) + word0 (da) += k * Exp_msk1; + else + { + k = -k; + word0 (db) += k * Exp_msk1; + } +#endif + return da.d / db.d; +} + + +_CONST double + tens[] = +{ + 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, + 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, + 1e20, 1e21, 1e22, 1e23, 1e24 + +}; + +#if !defined(_DOUBLE_IS_32BITS) && !defined(__v800) +_CONST double bigtens[] = +{1e16, 1e32, 1e64, 1e128, 1e256}; + +_CONST double tinytens[] = +{1e-16, 1e-32, 1e-64, 1e-128, 1e-256}; +#else +_CONST double bigtens[] = +{1e16, 1e32}; + +_CONST double tinytens[] = +{1e-16, 1e-32}; +#endif + + diff --git a/libjava/java/lang/mprec.h b/libjava/java/lang/mprec.h new file mode 100644 index 00000000000..192243157df --- /dev/null +++ b/libjava/java/lang/mprec.h @@ -0,0 +1,374 @@ +/**************************************************************** + * + * The author of this software is David M. Gay. + * + * Copyright (c) 1991 by AT&T. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose without fee is hereby granted, provided that this entire notice + * is included in all copies of any software which is or includes a copy + * or modification of this software and in all copies of the supporting + * documentation for such software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY + * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. + * + ***************************************************************/ + +/* Please send bug reports to + David M. Gay + AT&T Bell Laboratories, Room 2C-463 + 600 Mountain Avenue + Murray Hill, NJ 07974-2070 + U.S.A. + dmg@research.att.com or research!dmg + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "ieeefp.h" + +#include +// #include +// #include + +/* These typedefs are true for the targets running Java. */ + +#ifndef HAVE_INT32_DEFINED +typedef int __int32_t; +typedef unsigned int __uint32_t; +#endif + +#ifdef __IEEE_LITTLE_ENDIAN +#define IEEE_8087 +#endif + +#ifdef __IEEE_BIG_ENDIAN +#define IEEE_MC68k +#endif + +#ifdef __Z8000__ +#define Just_16 +#endif + +#ifdef DEBUG +#include "stdio.h" +#define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);} +#endif + + +#ifdef Unsigned_Shifts +#define Sign_Extend(a,b) if (b < 0) a |= (__uint32_t)0xffff0000; +#else +#define Sign_Extend(a,b) /*no-op*/ +#endif + +#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1 +Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined. +#endif + +/* If we are going to examine or modify specific bits in a double using + the word0 and/or word1 macros, then we must wrap the double inside + a union. This is necessary to avoid undefined behavior according to + the ANSI C spec. */ +union double_union +{ + double d; + // FIXME: This should be some well-defined 32 bit type. + __uint32_t i[2]; +}; + +#ifdef IEEE_8087 +#define word0(x) (x.i[1]) +#define word1(x) (x.i[0]) +#else +#define word0(x) (x.i[0]) +#define word1(x) (x.i[1]) +#endif + +/* The following definition of Storeinc is appropriate for MIPS processors. + * An alternative that might be better on some machines is + * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff) + */ +#if defined(IEEE_8087) + defined(VAX) +#define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \ +((unsigned short *)a)[0] = (unsigned short)c, a++) +#else +#define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \ +((unsigned short *)a)[1] = (unsigned short)c, a++) +#endif + +/* #define P DBL_MANT_DIG */ +/* Ten_pmax = floor(P*log(2)/log(5)) */ +/* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */ +/* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */ +/* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */ + +#if defined(IEEE_8087) + defined(IEEE_MC68k) +#if defined (_DOUBLE_IS_32BITS) +#define Exp_shift 23 +#define Exp_shift1 23 +#define Exp_msk1 ((__uint32_t)0x00800000L) +#define Exp_msk11 ((__uint32_t)0x00800000L) +#define Exp_mask ((__uint32_t)0x7f800000L) +#define P 24 +#define Bias 127 +#if 0 +#define IEEE_Arith /* it is, but the code doesn't handle IEEE singles yet */ +#endif +#define Emin (-126) +#define Exp_1 ((__uint32_t)0x3f800000L) +#define Exp_11 ((__uint32_t)0x3f800000L) +#define Ebits 8 +#define Frac_mask ((__uint32_t)0x007fffffL) +#define Frac_mask1 ((__uint32_t)0x007fffffL) +#define Ten_pmax 10 +#define Sign_bit ((__uint32_t)0x80000000L) +#define Ten_pmax 10 +#define Bletch 2 +#define Bndry_mask ((__uint32_t)0x007fffffL) +#define Bndry_mask1 ((__uint32_t)0x007fffffL) +#define LSB 1 +#define Sign_bit ((__uint32_t)0x80000000L) +#define Log2P 1 +#define Tiny0 0 +#define Tiny1 1 +#define Quick_max 5 +#define Int_max 6 +#define Infinite(x) (word0(x) == ((__uint32_t)0x7f800000L)) +#undef word0 +#undef word1 + +#define word0(x) (x.i[0]) +#define word1(x) 0 +#else + +#define Exp_shift 20 +#define Exp_shift1 20 +#define Exp_msk1 ((__uint32_t)0x100000L) +#define Exp_msk11 ((__uint32_t)0x100000L) +#define Exp_mask ((__uint32_t)0x7ff00000L) +#define P 53 +#define Bias 1023 +#define IEEE_Arith +#define Emin (-1022) +#define Exp_1 ((__uint32_t)0x3ff00000L) +#define Exp_11 ((__uint32_t)0x3ff00000L) +#define Ebits 11 +#define Frac_mask ((__uint32_t)0xfffffL) +#define Frac_mask1 ((__uint32_t)0xfffffL) +#define Ten_pmax 22 +#define Bletch 0x10 +#define Bndry_mask ((__uint32_t)0xfffffL) +#define Bndry_mask1 ((__uint32_t)0xfffffL) +#define LSB 1 +#define Sign_bit ((__uint32_t)0x80000000L) +#define Log2P 1 +#define Tiny0 0 +#define Tiny1 1 +#define Quick_max 14 +#define Int_max 14 +#define Infinite(x) (word0(x) == ((__uint32_t)0x7ff00000L)) /* sufficient test for here */ +#endif + +#else +#undef Sudden_Underflow +#define Sudden_Underflow +#ifdef IBM +#define Exp_shift 24 +#define Exp_shift1 24 +#define Exp_msk1 ((__uint32_t)0x1000000L) +#define Exp_msk11 ((__uint32_t)0x1000000L) +#define Exp_mask ((__uint32_t)0x7f000000L) +#define P 14 +#define Bias 65 +#define Exp_1 ((__uint32_t)0x41000000L) +#define Exp_11 ((__uint32_t)0x41000000L) +#define Ebits 8 /* exponent has 7 bits, but 8 is the right value in b2d */ +#define Frac_mask ((__uint32_t)0xffffffL) +#define Frac_mask1 ((__uint32_t)0xffffffL) +#define Bletch 4 +#define Ten_pmax 22 +#define Bndry_mask ((__uint32_t)0xefffffL) +#define Bndry_mask1 ((__uint32_t)0xffffffL) +#define LSB 1 +#define Sign_bit ((__uint32_t)0x80000000L) +#define Log2P 4 +#define Tiny0 ((__uint32_t)0x100000L) +#define Tiny1 0 +#define Quick_max 14 +#define Int_max 15 +#else /* VAX */ +#define Exp_shift 23 +#define Exp_shift1 7 +#define Exp_msk1 0x80 +#define Exp_msk11 ((__uint32_t)0x800000L) +#define Exp_mask ((__uint32_t)0x7f80L) +#define P 56 +#define Bias 129 +#define Exp_1 ((__uint32_t)0x40800000L) +#define Exp_11 ((__uint32_t)0x4080L) +#define Ebits 8 +#define Frac_mask ((__uint32_t)0x7fffffL) +#define Frac_mask1 ((__uint32_t)0xffff007fL) +#define Ten_pmax 24 +#define Bletch 2 +#define Bndry_mask ((__uint32_t)0xffff007fL) +#define Bndry_mask1 ((__uint32_t)0xffff007fL) +#define LSB ((__uint32_t)0x10000L) +#define Sign_bit ((__uint32_t)0x8000L) +#define Log2P 1 +#define Tiny0 0x80 +#define Tiny1 0 +#define Quick_max 15 +#define Int_max 15 +#endif +#endif + +#ifndef IEEE_Arith +#define ROUND_BIASED +#endif + +#ifdef RND_PRODQUOT +#define rounded_product(a,b) a = rnd_prod(a, b) +#define rounded_quotient(a,b) a = rnd_quot(a, b) +#ifdef KR_headers +extern double rnd_prod(), rnd_quot(); +#else +extern double rnd_prod(double, double), rnd_quot(double, double); +#endif +#else +#define rounded_product(a,b) a *= b +#define rounded_quotient(a,b) a /= b +#endif + +#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) +#define Big1 ((__uint32_t)0xffffffffL) + +#ifndef Just_16 +/* When Pack_32 is not defined, we store 16 bits per 32-bit long. + * This makes some inner loops simpler and sometimes saves work + * during multiplications, but it often seems to make things slightly + * slower. Hence the default is now to store 32 bits per long. + */ + +#ifndef Pack_32 +#define Pack_32 +#endif +#endif + + +#define MAX_BIGNUMS 16 +#define MAX_BIGNUM_WDS 32 + +struct _Jv_Bigint +{ + struct _Jv_Bigint *_next; + int _k, _maxwds, _sign, _wds; + unsigned long _x[MAX_BIGNUM_WDS]; +}; + + +#define _PTR void * +#define _AND , +#define _NOARGS void +#define _CONST const +#define _VOLATILE volatile +#define _SIGNED signed +#define _DOTS , ... +#define _VOID void +#define _EXFUN(name, proto) name proto +#define _DEFUN(name, arglist, args) name(args) +#define _DEFUN_VOID(name) name(_NOARGS) +#define _CAST_VOID (void) + + +struct _Jv_reent +{ + /* local copy of errno */ + int _errno; + + /* used by mprec routines */ + struct _Jv_Bigint *_result; + int _result_k; + struct _Jv_Bigint *_p5s; + + struct _Jv_Bigint _freelist[MAX_BIGNUMS]; + int _allocation_map; + + int num; +}; + + +typedef struct _Jv_Bigint _Jv_Bigint; + +#define Balloc _Jv_Balloc +#define Bfree _Jv_Bfree +#define multadd _Jv_multadd +#define s2b _Jv_s2b +#define lo0bits _Jv_lo0bits +#define hi0bits _Jv_hi0bits +#define i2b _Jv_i2b +#define mult _Jv_mult +#define pow5mult _Jv_pow5mult +#define lshift _Jv_lshift +#define cmp _Jv__mcmp +#define diff _Jv__mdiff +#define ulp _Jv_ulp +#define b2d _Jv_b2d +#define d2b _Jv_d2b +#define ratio _Jv_ratio + +#define tens _Jv__mprec_tens +#define bigtens _Jv__mprec_bigtens +#define tinytens _Jv__mprec_tinytens + +#define _dtoa _Jv_dtoa +#define _dtoa_r _Jv_dtoa_r +#define _strtod_r _Jv_strtod_r + +extern double _EXFUN(_strtod_r, (struct _Jv_reent *ptr, const char *s00, char **se)); +extern char* _EXFUN(_dtoa_r, (struct _Jv_reent *ptr, double d, + int mode, int ndigits, int *decpt, int *sign, + char **rve, int float_type)); +void _EXFUN(_dtoa, (double d, int mode, int ndigits, int *decpt, int *sign, + char **rve, char *buf, int float_type)); + +double _EXFUN(ulp,(double x)); +double _EXFUN(b2d,(_Jv_Bigint *a , int *e)); +_Jv_Bigint * _EXFUN(Balloc,(struct _Jv_reent *p, int k)); +void _EXFUN(Bfree,(struct _Jv_reent *p, _Jv_Bigint *v)); +_Jv_Bigint * _EXFUN(multadd,(struct _Jv_reent *p, _Jv_Bigint *, int, int)); +_Jv_Bigint * _EXFUN(s2b,(struct _Jv_reent *, const char*, int, int, unsigned long)); +_Jv_Bigint * _EXFUN(i2b,(struct _Jv_reent *,int)); +_Jv_Bigint * _EXFUN(mult, (struct _Jv_reent *, _Jv_Bigint *, _Jv_Bigint *)); +_Jv_Bigint * _EXFUN(pow5mult, (struct _Jv_reent *, _Jv_Bigint *, int k)); +int _EXFUN(hi0bits,(unsigned long)); +int _EXFUN(lo0bits,(unsigned long *)); +_Jv_Bigint * _EXFUN(d2b,(struct _Jv_reent *p, double d, int *e, int *bits)); +_Jv_Bigint * _EXFUN(lshift,(struct _Jv_reent *p, _Jv_Bigint *b, int k)); +_Jv_Bigint * _EXFUN(diff,(struct _Jv_reent *p, _Jv_Bigint *a, _Jv_Bigint *b)); +int _EXFUN(cmp,(_Jv_Bigint *a, _Jv_Bigint *b)); + +double _EXFUN(ratio,(_Jv_Bigint *a, _Jv_Bigint *b)); +#define Bcopy(x,y) memcpy((char *)&x->_sign, (char *)&y->_sign, y->_wds*sizeof(long) + 2*sizeof(int)) + +#if defined(_DOUBLE_IS_32BITS) && defined(__v800) +#define n_bigtens 2 +#else +#define n_bigtens 5 +#endif + +extern _CONST double tinytens[]; +extern _CONST double bigtens[]; +extern _CONST double tens[]; + +#ifdef __cplusplus +} +#endif + diff --git a/libjava/java/lang/natCharacter.cc b/libjava/java/lang/natCharacter.cc new file mode 100644 index 00000000000..36cf5700fe5 --- /dev/null +++ b/libjava/java/lang/natCharacter.cc @@ -0,0 +1,269 @@ +// natCharacter.cc - Native part of Character class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include +#include + +#include + + + +#define asize(x) ((sizeof (x)) / sizeof (x[0])) + +static jchar +to_lower_title (jchar ch) +{ + for (unsigned int i = 0; i < asize (title_to_upper_table); ++i) + { + // We can assume that the entries in the two tables are + // parallel. This is checked in the script. + if (title_to_upper_table[i][1] == ch + || title_to_upper_table[i][0] == ch) + return title_to_lower_table[i][1]; + } + return ch; +} + +static jchar +to_upper_title (jchar ch) +{ + for (unsigned int i = 0; i < asize (title_to_lower_table); ++i) + { + // We can assume that the entries in the two tables are + // parallel. This is checked in the script. + if (title_to_lower_table[i][1] == ch + || title_to_lower_table[i][0] == ch) + return title_to_upper_table[i][1]; + } + return ch; +} + +jboolean +java::lang::Character::isTitleCase (jchar ch) +{ + for (unsigned int i = 0; i < asize (title_to_lower_table); ++i) + { + if (title_to_lower_table[i][0] == ch) + return true; + } + return false; +} + +jchar +java::lang::Character::toTitleCase (jchar ch) +{ + // Both titlecase mapping tables have the same length. This is + // checked in the chartables script. + for (unsigned int i = 0; i < asize (title_to_lower_table); ++i) + { + if (title_to_lower_table[i][0] == ch) + return ch; + if (title_to_lower_table[i][1] == ch) + return title_to_lower_table[i][0]; + if (title_to_upper_table[i][1] == ch) + return title_to_upper_table[i][0]; + } + return toUpperCase (ch); +} + +#ifdef COMPACT_CHARACTER + +static int +table_search (const jchar table[][2], int table_len, jchar ch) +{ + int low, high, i, old; + + low = 0; + high = table_len; + i = high / 2; + + while (true) + { + if (ch < table[i][0]) + high = i; + else if (ch > table[i][1]) + low = i; + else + return i; + + old = i; + i = (high + low) / 2; + if (i == old) + break; + } + + return -1; +} + +jint +java::lang::Character::digit_value (jchar ch) +{ + int index = table_search (digit_table, asize (digit_table), ch); + if (index == -1) + return -1; + + jchar base = digit_table[index][0]; + // Tamil doesn't have a digit `0'. So we special-case it here. + if (base == TAMIL_DIGIT_ONE) + return ch - base + 1; + return ch - base; +} + +jint +java::lang::Character::getNumericValue (jchar ch) +{ + jint d = digit (ch, 36); + if (d != -1) + return d; + + for (unsigned int i = 0; i < asize (numeric_table); ++i) + { + if (numeric_table[i] == ch) + return numeric_value[i]; + } + + return -1; +} + +jint +java::lang::Character::getType (jchar ch) +{ + int index = table_search (all_table, asize (all_table), ch); + if (index != -1) + return category_table[index]; + return UNASSIGNED; +} + +jboolean +java::lang::Character::isLowerCase (jchar ch) +{ + if (ch >= 0x2000 && ch <= 0x2fff) + return false; + if (table_search (lower_case_table, asize (lower_case_table), ch) != -1) + return true; + + // FIXME: use a binary search. + for (unsigned int i = 0; i < asize (lower_anomalous_table); ++i) + { + if (lower_anomalous_table[i] == ch) + return true; + } + return false; +} + +jboolean +java::lang::Character::isSpaceChar (jchar ch) +{ + return table_search (space_table, asize (space_table), ch) != -1; +} + +jboolean +java::lang::Character::isUpperCase (jchar ch) +{ + if (ch >= 0x2000 && ch <= 0x2fff) + return false; + return table_search (upper_case_table, asize (upper_case_table), ch) != -1; +} + +jchar +java::lang::Character::toLowerCase (jchar ch) +{ + int index = table_search (upper_case_table, asize (upper_case_table), ch); + if (index == -1) + return to_lower_title (ch); + return (jchar) (ch - upper_case_table[index][0] + + upper_case_map_table[index]); +} + +jchar +java::lang::Character::toUpperCase (jchar ch) +{ + int index = table_search (lower_case_table, asize (lower_case_table), ch); + if (index == -1) + return to_upper_title (ch); + return (jchar) (ch - lower_case_table[index][0] + + lower_case_map_table[index]); +} + +#else /* COMPACT_CHARACTER */ + +jint +java::lang::Character::digit_value (jchar ch) +{ + if (type_table[ch] == DECIMAL_DIGIT_NUMBER) + return attribute_table[ch]; + return -1; +} + +jint +java::lang::Character::getNumericValue (jchar ch) +{ + jint d = digit (ch, 36); + if (d != -1) + return d; + + // Some characters require two attributes. We special-case them here. + if (ch >= ROMAN_START && ch <= ROMAN_END) + return secondary_attribute_table[ch - ROMAN_START]; + if (type_table[ch] == LETTER_NUMBER || type_table[ch] == OTHER_NUMBER) + return attribute_table[ch]; + return -1; +} + +jint +java::lang::Character::getType (jchar ch) +{ + return type_table[ch]; +} + +jboolean +java::lang::Character::isLowerCase (jchar ch) +{ + if (ch >= 0x2000 && ch <= 0x2fff) + return false; + return type_table[ch] == LOWERCASE_LETTER; +} + +jboolean +java::lang::Character::isSpaceChar (jchar ch) +{ + return (type_table[ch] == SPACE_SEPARATOR + || type_table[ch] == LINE_SEPARATOR + || type_table[ch] == PARAGRAPH_SEPARATOR); +} + +jboolean +java::lang::Character::isUpperCase (jchar ch) +{ + if (ch >= 0x2000 && ch <= 0x2fff) + return false; + return type_table[ch] == UPPERCASE_LETTER; +} + +jchar +java::lang::Character::toLowerCase (jchar ch) +{ + if (type_table[ch] == UPPERCASE_LETTER) + return attribute_table[ch]; + return to_lower_title (ch); +} + +jchar +java::lang::Character::toUpperCase (jchar ch) +{ + if (type_table[ch] == LOWERCASE_LETTER) + return attribute_table[ch]; + return to_upper_title (ch); +} + +#endif /* COMPACT_CHARACTER */ diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc new file mode 100644 index 00000000000..1768df5ecb2 --- /dev/null +++ b/libjava/java/lang/natClass.cc @@ -0,0 +1,785 @@ +// natClass.cc - Implementation of java.lang.Class native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include + +#pragma implementation "Class.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#define CloneableClass _CL_Q34java4lang9Cloneable +extern java::lang::Class CloneableClass; +#define ObjectClass _CL_Q34java4lang6Object +extern java::lang::Class ObjectClass; +#define ErrorClass _CL_Q34java4lang5Error +extern java::lang::Class ErrorClass; +#define ClassClass _CL_Q34java4lang5Class +extern java::lang::Class ClassClass; +#define MethodClass _CL_Q44java4lang7reflect6Method +extern java::lang::Class MethodClass; +#define FieldClass _CL_Q44java4lang7reflect5Field +extern java::lang::Class FieldClass; + +// Some constants we use to look up the class initializer. +static _Jv_Utf8Const *void_signature = _Jv_makeUtf8Const ("()V", 3); +static _Jv_Utf8Const *clinit_name = _Jv_makeUtf8Const ("", 8); +static _Jv_Utf8Const *init_name = _Jv_makeUtf8Const ("", 6); + +// These are the possible values for the `state' field. They more or +// less follow the section numbers in the Java Language Spec. Right +// now we don't bother to represent other interesting states, e.g. the +// states a class might inhabit before it is prepared. Note that +// ordering is important here; in particular `resolved' must come +// between `nothing' and the other states. +#define STATE_NOTHING 0 +#define STATE_RESOLVED 1 +#define STATE_IN_PROGRESS 6 +#define STATE_DONE 9 +#define STATE_ERROR 10 + +// Size of local hash table. +#define HASH_LEN 256 + +// Hash function for Utf8Consts. +#define HASH_UTF(Utf) (((Utf)->hash) % HASH_LEN) + +// This is the table we use to keep track of loaded classes. See Spec +// section 12.2. +static jclass loaded_classes[HASH_LEN]; + + + +jclass +java::lang::Class::forName (jstring className) +{ + if (! className) + JvThrow (new java::lang::NullPointerException); + +#if 0 + // FIXME: should check syntax of CLASSNAME and throw + // IllegalArgumentException on failure. + + // FIXME: should use class loader from calling method. + jclass klass = _Jv_FindClass (className, NULL); +#else + jsize length = _Jv_GetStringUTFLength (className); + char buffer[length]; + _Jv_GetStringUTFRegion (className, 0, length, buffer); + + // FIXME: should check syntax of CLASSNAME and throw + // IllegalArgumentException on failure. + _Jv_Utf8Const *name = _Jv_makeUtf8Const (buffer, length); + + // FIXME: should use class loader from calling method. + jclass klass = (buffer[0] == '[' + ? _Jv_FindClassFromSignature (name->data, NULL) + : _Jv_FindClass (name, NULL)); +#endif + if (! klass) + JvThrow (new java::lang::ClassNotFoundException (className)); + return klass; +} + +java::lang::reflect::Constructor * +java::lang::Class::getConstructor (JArray *) +{ + JvFail ("java::lang::Class::getConstructor not implemented"); +} + +JArray * +java::lang::Class::getConstructors (void) +{ + JvFail ("java::lang::Class::getConstructors not implemented"); +} + +java::lang::reflect::Constructor * +java::lang::Class::getDeclaredConstructor (JArray *) +{ + JvFail ("java::lang::Class::getDeclaredConstructor not implemented"); +} + +JArray * +java::lang::Class::getDeclaredConstructors (void) +{ + JvFail ("java::lang::Class::getDeclaredConstructors not implemented"); +} + +java::lang::reflect::Field * +java::lang::Class::getField (jstring name, jint hash) +{ + java::lang::reflect::Field* rfield; + for (int i = 0; i < field_count; i++) + { + _Jv_Field *field = &fields[i]; + if (! _Jv_equal (field->name, name, hash)) + continue; + if (! (field->getModifiers() & java::lang::reflect::Modifier::PUBLIC)) + continue; + rfield = new java::lang::reflect::Field (); + rfield->offset = (char*) field - (char*) fields; + rfield->declaringClass = this; + rfield->name = name; + return rfield; + } + jclass superclass = getSuperclass(); + if (superclass == NULL) + return NULL; + rfield = superclass->getField(name, hash); + for (int i = 0; i < interface_count && rfield == NULL; ++i) + rfield = interfaces[i]->getField (name, hash); + return rfield; +} + +java::lang::reflect::Field * +java::lang::Class::getDeclaredField (jstring name) +{ + java::lang::SecurityManager *s = java::lang::System::getSecurityManager(); + if (s != NULL) + s->checkMemberAccess (this, java::lang::reflect::Member::DECLARED); + int hash = name->hashCode(); + for (int i = 0; i < field_count; i++) + { + _Jv_Field *field = &fields[i]; + if (! _Jv_equal (field->name, name, hash)) + continue; + java::lang::reflect::Field* rfield = new java::lang::reflect::Field (); + rfield->offset = (char*) field - (char*) fields; + rfield->declaringClass = this; + rfield->name = name; + return rfield; + } + JvThrow (new java::lang::NoSuchFieldException (name)); +} + +JArray * +java::lang::Class::getDeclaredFields (void) +{ + java::lang::SecurityManager *s = java::lang::System::getSecurityManager(); + if (s != NULL) + s->checkMemberAccess (this, java::lang::reflect::Member::DECLARED); + JArray *result + = (JArray *) + JvNewObjectArray (field_count, &FieldClass, NULL); + java::lang::reflect::Field** fptr = elements (result); + for (int i = 0; i < field_count; i++) + { + _Jv_Field *field = &fields[i]; + java::lang::reflect::Field* rfield = new java::lang::reflect::Field (); + rfield->offset = (char*) field - (char*) fields; + rfield->declaringClass = this; + *fptr++ = rfield; + } + return result; +} + +java::lang::reflect::Method * +java::lang::Class::getDeclaredMethod (jstring, JArray *) +{ + JvFail ("java::lang::Class::getDeclaredMethod not implemented"); +} + +JArray * +java::lang::Class::getDeclaredMethods (void) +{ + int numMethods = 0; + int i; + for (i = method_count; --i >= 0; ) + { + _Jv_Method *method = &methods[i]; + if (method->name == NULL + || _Jv_equalUtf8Consts (method->name, clinit_name) + || _Jv_equalUtf8Consts (method->name, init_name)) + continue; + numMethods++; + } + JArray *result + = (JArray *) + JvNewObjectArray (numMethods, &MethodClass, NULL); + java::lang::reflect::Method** mptr = elements (result); + for (i = 0; i < method_count; i++) + { + _Jv_Method *method = &methods[i]; + if (method->name == NULL + || _Jv_equalUtf8Consts (method->name, clinit_name) + || _Jv_equalUtf8Consts (method->name, init_name)) + continue; + java::lang::reflect::Method* rmethod = new java::lang::reflect::Method (); + rmethod->offset = (char*) mptr - (char*) elements (result); + rmethod->declaringClass = this; + *mptr++ = rmethod; + } + return result; +} + +jstring +java::lang::Class::getName (void) +{ + char buffer[name->length + 1]; + memcpy (buffer, name->data, name->length); + buffer[name->length] = '\0'; + return _Jv_NewStringUTF (buffer); +} + +JArray * +java::lang::Class::getClasses (void) +{ + // FIXME: implement. + return NULL; +} + +JArray * +java::lang::Class::getDeclaredClasses (void) +{ + checkMemberAccess (java::lang::reflect::Member::DECLARED); + JvFail ("java::lang::Class::getDeclaredClasses not implemented"); + return NULL; // Placate compiler. +} + +// This is marked as unimplemented in the JCL book. +jclass +java::lang::Class::getDeclaringClass (void) +{ + JvFail ("java::lang::Class::getDeclaringClass unimplemented"); + return NULL; // Placate compiler. +} + +JArray * +java::lang::Class::getFields (void) +{ + JvFail ("java::lang::Class::getFields not implemented"); +} + +JArray * +java::lang::Class::getInterfaces (void) +{ + jobjectArray r = JvNewObjectArray (interface_count, getClass (), NULL); + jobject *data = elements (r); + for (int i = 0; i < interface_count; ++i) + data[i] = interfaces[i]; + return reinterpret_cast *> (r); +} + +java::lang::reflect::Method * +java::lang::Class::getMethod (jstring, JArray *) +{ + JvFail ("java::lang::Class::getMethod not implemented"); +} + +JArray * +java::lang::Class::getMethods (void) +{ + JvFail ("java::lang::Class::getMethods not implemented"); +} + +jboolean +java::lang::Class::isAssignableFrom (jclass klass) +{ + if (this == klass) + return true; + // Primitive types must be equal, which we just tested for. + if (isPrimitive () || ! klass || klass->isPrimitive()) + return false; + + // If target is array, so must source be. + if (isArray ()) + { + if (! klass->isArray()) + return false; + return getComponentType()->isAssignableFrom(klass->getComponentType()); + } + + if (isAssignableFrom (klass->getSuperclass())) + return true; + + if (isInterface()) + { + // See if source implements this interface. + for (int i = 0; i < klass->interface_count; ++i) + { + jclass interface = klass->interfaces[i]; + // FIXME: ensure that class is prepared here. + // See Spec 12.3.2. + if (isAssignableFrom (interface)) + return true; + } + } + + return false; +} + +jboolean +java::lang::Class::isInstance (jobject obj) +{ + if (! obj || isPrimitive ()) + return false; + return isAssignableFrom (obj->getClass()); +} + +jboolean +java::lang::Class::isInterface (void) +{ + return (accflags & java::lang::reflect::Modifier::INTERFACE) != 0; +} + +jobject +java::lang::Class::newInstance (void) +{ + // FIXME: do accessibility checks here. There currently doesn't + // seem to be any way to do these. + // FIXME: we special-case one check here just to pass a Plum Hall + // test. Once access checking is implemented, remove this. + if (this == &ClassClass) + JvThrow (new java::lang::IllegalAccessException); + + if (isPrimitive () + || isInterface () + || isArray () + || java::lang::reflect::Modifier::isAbstract(accflags)) + JvThrow (new java::lang::InstantiationException); + + _Jv_Method *meth = _Jv_GetMethodLocal (this, init_name, void_signature); + if (! meth) + JvThrow (new java::lang::NoSuchMethodException); + + jobject r = JvAllocObject (this); + ((void (*) (jobject)) meth->ncode) (r); + return r; +} + +// Initialize the constants. +void +java::lang::Class::resolveConstants (void) +{ + for (int i = 0; i < constants.size; ++i) + { + if (constants.tags[i] == CONSTANT_String) + { + jstring str; + str = _Jv_NewStringUtf8Const ((_Jv_Utf8Const *) constants.data[i]); + constants.data[i] = (void *) str; + constants.tags[i] = CONSTANT_ResolvedString; + } + else if (constants.tags[i] == CONSTANT_Class) + { + _Jv_Utf8Const *name = (_Jv_Utf8Const *) constants.data[i]; + jclass klass = _Jv_FindClassFromSignature (name->data, loader); + if (! klass) + { + jstring str = _Jv_NewStringUtf8Const (name); + JvThrow (new java::lang::ClassNotFoundException (str)); + } + + constants.data[i] = (void *) klass; + constants.tags[i] = CONSTANT_ResolvedClass; + } + } +} + +// FIXME. +void +java::lang::Class::hackRunInitializers (void) +{ + _Jv_Method *meth = _Jv_GetMethodLocal (this, clinit_name, void_signature); + if (meth) + ((void (*) (void)) meth->ncode) (); +} + +// This implements the initialization process for a class. From Spec +// section 12.4.2. +void +java::lang::Class::initializeClass (void) +{ + // Short-circuit to avoid needless locking. + if (state == STATE_DONE) + return; + + // Step 1. + _Jv_MonitorEnter (this); + + // FIXME: This should actually be handled by calling into the class + // loader. For now we put it here. + if (state < STATE_RESOLVED) + { + // We set the state before calling resolveConstants to avoid + // infinite recursion when processing String or Class. + state = STATE_RESOLVED; + resolveConstants (); + } + + // Step 2. + java::lang::Thread *self = java::lang::Thread::currentThread(); + // FIXME: `self' can be null at startup. Hence this nasty trick. + self = (java::lang::Thread *) ((long) self | 1); + while (state == STATE_IN_PROGRESS && thread && thread != self) + wait (); + + // Steps 3 & 4. + if (state == STATE_DONE || state == STATE_IN_PROGRESS || thread == self) + { + _Jv_MonitorExit (this); + return; + } + + // Step 5. + if (state == STATE_ERROR) + { + _Jv_MonitorExit (this); + JvThrow (new java::lang::NoClassDefFoundError); + } + + // Step 6. + thread = self; + state = STATE_IN_PROGRESS; + _Jv_MonitorExit (this); + + // Step 7. + if (! isInterface () && superclass) + { + // FIXME: We can't currently catch a Java exception in C++ code. + // So instead we call a Java trampoline. It returns an + // exception, or null. + jobject except = superclass->hackTrampoline(0, NULL); + if (except) + { + // Caught an exception. + _Jv_MonitorEnter (this); + state = STATE_ERROR; + notify (); + _Jv_MonitorExit (this); + JvThrow (except); + } + } + + // Step 8. + // FIXME: once again we have to go through a trampoline. + java::lang::Throwable *except = hackTrampoline (1, NULL); + + // Steps 9, 10, 11. + if (! except) + { + _Jv_MonitorEnter (this); + state = STATE_DONE; + } + else + { + if (! ErrorClass.isInstance(except)) + { + // Once again we must use the trampoline. In this case we + // have to detect an OutOfMemoryError. + except = hackTrampoline(2, except); + } + _Jv_MonitorEnter (this); + state = STATE_ERROR; + } + notify (); + _Jv_MonitorExit (this); + if (except) + JvThrow (except); +} + + + +// +// Some class-related convenience functions. +// + +_Jv_Method * +_Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name, + _Jv_Utf8Const *signature) +{ + for (int i = 0; i < klass->method_count; ++i) + { + if (_Jv_equalUtf8Consts (name, klass->methods[i].name) + && _Jv_equalUtf8Consts (signature, klass->methods[i].signature)) + return &klass->methods[i]; + } + return NULL; +} + +void * +_Jv_LookupInterfaceMethod (jclass klass, _Jv_Utf8Const *name, + _Jv_Utf8Const *signature) +{ + // FIXME: can't do this until we have a working class loader. + // This probably isn't the right thing to do anyway, since we can't + // call a method of a class until the class is linked. But this + // captures the general idea. + // klass->getClassLoader()->resolveClass(klass); + + for (; klass; klass = klass->getSuperclass()) + { + _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature); + if (! meth) + continue; + + if (java::lang::reflect::Modifier::isStatic(meth->accflags)) + JvThrow (new java::lang::IncompatibleClassChangeError); + if (java::lang::reflect::Modifier::isAbstract(meth->accflags)) + JvThrow (new java::lang::AbstractMethodError); + if (! java::lang::reflect::Modifier::isPublic(meth->accflags)) + JvThrow (new java::lang::IllegalAccessError); + + return meth->ncode; + } + JvThrow (new java::lang::IncompatibleClassChangeError); + return NULL; // Placate compiler. +} + +void +_Jv_InitClass (jclass klass) +{ + klass->initializeClass(); +} + +// This function is called many times during startup, before main() is +// run. We do our runtime initialization here the very first time we +// are called. At that point in time we know for certain we are +// running single-threaded, so we don't need to lock when modifying +// `init'. CLASSES is NULL-terminated. +void +_Jv_RegisterClasses (jclass *classes) +{ + static bool init = false; + + if (! init) + { + init = true; + _Jv_InitThreads (); + _Jv_InitGC (); + _Jv_InitializeSyncMutex (); + } + + JvSynchronize sync (&ClassClass); + for (; *classes; ++classes) + { + jclass klass = *classes; + jint hash = HASH_UTF (klass->name); + klass->next = loaded_classes[hash]; + loaded_classes[hash] = klass; + } +} + +void +_Jv_RegisterClass (jclass klass) +{ + jclass classes[2]; + classes[0] = klass; + classes[1] = NULL; + _Jv_RegisterClasses (classes); +} + +jclass +_Jv_FindClassInCache (_Jv_Utf8Const *name, java::lang::ClassLoader *loader) +{ + JvSynchronize sync (&ClassClass); + jint hash = HASH_UTF (name); + jclass klass; + for (klass = loaded_classes[hash]; klass; klass = klass->next) + { + if (loader == klass->loader && _Jv_equalUtf8Consts (name, klass->name)) + break; + } + return klass; +} + +#if 0 +jclass +_Jv_FindClassInCache (jstring name, java::lang::ClassLoader *loader) +{ + JvSynchronize sync (&ClassClass); + jint hash = name->hashCode(); + jclass klass = loaded_classes[(_Jv_ushort) hash % HASH_LEN]; + for ( ; klass; klass = klass->next) + { + if (loader == klass->loader + && _Jv_equalUtf8Consts (klass->name, name, hash)) + break; + } + return klass; +} +#endif + +jclass +_Jv_FindClass (_Jv_Utf8Const* name, java::lang::ClassLoader *loader) +{ + jclass klass = _Jv_FindClassInCache (name, loader); + if (loader && ! klass) + { + klass = loader->loadClass(_Jv_NewStringUtf8Const (name)); + if (klass) + _Jv_RegisterClass (klass); + } + return klass; +} + +#if 0 +jclass +_Jv_FindClass (jstring name, java::lang::ClassLoader *loader) +{ + jclass klass = _Jv_FindClassInCache (name, loader); + if (loader && ! klass) + { + klass = loader->loadClass(name); + if (klass) + _Jv_RegisterClass (klass); + } + return klass; +} +#endif + +jclass +_Jv_NewClass (_Jv_Utf8Const *name, jclass superclass, + java::lang::ClassLoader *loader) +{ + jclass ret = (jclass) JvAllocObject (&ClassClass); + + ret->next = NULL; + ret->name = name; + ret->accflags = 0; + ret->superclass = superclass; + ret->constants.size = 0; + ret->constants.tags = NULL; + ret->constants.data = NULL; + ret->methods = NULL; + ret->method_count = 0; + ret->vtable_method_count = 0; + ret->fields = NULL; + ret->size_in_bytes = 0; + ret->field_count = 0; + ret->static_field_count = 0; + ret->vtable = NULL; + ret->interfaces = NULL; + ret->loader = loader; + ret->interface_count = 0; + ret->state = 0; + ret->thread = NULL; + + _Jv_RegisterClass (ret); + + return ret; +} + +jclass +_Jv_FindArrayClass (jclass element) +{ + _Jv_Utf8Const *array_name; + int len; + if (element->isPrimitive()) + { + // For primitive types the array is cached in the class. + jclass ret = (jclass) element->methods; + if (ret) + return ret; + len = 3; + } + else + len = element->name->length + 5; + + { + char signature[len]; + int index = 0; + signature[index++] = '['; + // Compute name of array class to see if we've already cached it. + if (element->isPrimitive()) + { + signature[index++] = (char) element->method_count; + } + else + { + size_t length = element->name->length; + const char *const name = element->name->data; + if (name[0] != '[') + signature[index++] = 'L'; + memcpy (&signature[index], name, length); + index += length; + if (name[0] != '[') + signature[index++] = ';'; + } + array_name = _Jv_makeUtf8Const (signature, index); + } + + jclass array_class = _Jv_FindClassInCache (array_name, element->loader); + + if (! array_class) + { + // Create new array class. + array_class = _Jv_NewClass (array_name, &ObjectClass, element->loader); + + // Note that `vtable_method_count' doesn't include the initial + // NULL slot. + int dm_count = ObjectClass.vtable_method_count + 1; + + // Create a new vtable by copying Object's vtable (except the + // class pointer, of course). Note that we allocate this as + // unscanned memory -- the vtables are handled specially by the + // GC. + int size = (sizeof (_Jv_VTable) + + ((dm_count - 1) * sizeof (void *))); + _Jv_VTable *vtable = (_Jv_VTable *) _Jv_AllocBytes (size); + vtable->clas = array_class; + memcpy (vtable->method, ObjectClass.vtable->method, + dm_count * sizeof (void *)); + array_class->vtable = vtable; + array_class->vtable_method_count = ObjectClass.vtable_method_count; + + // Stash the pointer to the element type. + array_class->methods = (_Jv_Method *) element; + + // Register our interfaces. + // FIXME: for JDK 1.2 we need Serializable. + static jclass interfaces[] = { &CloneableClass }; + array_class->interfaces = interfaces; + array_class->interface_count = 1; + + // FIXME: initialize other Class instance variables, + // e.g. `fields'. + + array_class->state = STATE_DONE; + } + + // For primitive types, point back at this array. + if (element->isPrimitive()) + element->methods = (_Jv_Method *) array_class; + + return array_class; +} + +jboolean +_Jv_IsInstanceOf(jobject obj, jclass cl) +{ + return cl->isInstance(obj); +} diff --git a/libjava/java/lang/natDouble.cc b/libjava/java/lang/natDouble.cc new file mode 100644 index 00000000000..17990884751 --- /dev/null +++ b/libjava/java/lang/natDouble.cc @@ -0,0 +1,180 @@ +// natDouble.cc - Implementation of java.lang.Double native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/* AIX requires this to be the first thing in the file. */ +#ifndef __GNUC__ +# if HAVE_ALLOCA_H +# include +# else +# ifdef _AIX + #pragma alloca +# else +# ifndef alloca /* predefined by HP cc +Olibcalls */ +char *alloca (); +# endif +# endif +# endif +#endif + +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include "mprec.h" + +union u +{ + jlong l; + jdouble d; +}; + +jlong +java::lang::Double::doubleToLongBits(jdouble value) +{ + union u u; + u.d = value; + return u.l; +} + +jdouble +java::lang::Double::longBitsToDouble(jlong bits) +{ + union u u; + u.l = bits; + return u.d; +} + +jstring +java::lang::Double::toString(jdouble value, jboolean isFloat) +{ + if (isNaN (value)) + return JvNewStringLatin1 ("NaN", sizeof ("NaN") - 1); + + if (value == POSITIVE_INFINITY) + return JvNewStringLatin1 ("Infinity", sizeof ("Infinity") - 1); + + if (value == NEGATIVE_INFINITY) + return JvNewStringLatin1 ("-Infinity", sizeof ("-Infinity") - 1); + + char buffer[50], result[50]; + int decpt, sign; + + _dtoa (value, 0, 20, &decpt, &sign, NULL, buffer, (int)isFloat); + + value = fabs (value); + + char *s = buffer; + char *d = result; + + if (sign) + *d++ = '-'; + + if (value >= 1e-3 && value < 1e7 || value == 0) + { + if (decpt <= 0) + *d++ = '0'; + else + { + for (int i = 0; i < decpt; i++) + if (*s) + *d++ = *s++; + else + *d++ = '0'; + } + + *d++ = '.'; + + if (*s == 0) + { + *d++ = '0'; + decpt++; + } + + while (decpt++ < 0) + *d++ = '0'; + + while (*s) + *d++ = *s++; + + *d = 0; + + return JvNewStringLatin1 (result, strlen (result)); + } + + *d++ = *s++; + decpt--; + *d++ = '.'; + + if (*s == 0) + *d++ = '0'; + + while (*s) + *d++ = *s++; + + *d++ = 'E'; + + if (decpt < 0) + { + *d++ = '-'; + decpt = -decpt; + } + + { + char exp[4]; + char *e = exp + sizeof exp; + + *--e = 0; + do + { + *--e = '0' + decpt % 10; + decpt /= 10; + } + while (decpt > 0); + + while (*e) + *d++ = *e++; + } + + *d = 0; + + return JvNewStringLatin1 (result, strlen (result)); +} + +jdouble +java::lang::Double::doubleValueOf(jstring str) +{ + int length = str->length(); + // Note that UTF can expand 3x. + +#ifdef HAVE_ALLOCA + char *data = (char *) alloca (3 * length + 1); +#else +#error --- need an alternate implementation here --- +#endif + + data[_Jv_GetStringUTFRegion (str, 0, length, data)] = 0; + + struct _Jv_reent reent; + memset (&reent, 0, sizeof reent); + + double val = _strtod_r (&reent, data, NULL); + + if (reent._errno) + _Jv_Throw (new NumberFormatException); + + return val; +} diff --git a/libjava/java/lang/natFirstThread.cc b/libjava/java/lang/natFirstThread.cc new file mode 100644 index 00000000000..d47446be4a8 --- /dev/null +++ b/libjava/java/lang/natFirstThread.cc @@ -0,0 +1,56 @@ +// natFirstThread.cc - Implementation of FirstThread native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include + +#define DIE(Message) die (JvNewStringLatin1 (Message)) + +typedef void main_func (jobject); + +void +java::lang::FirstThread::run (void) +{ + Utf8Const* main_signature = _Jv_makeUtf8Const ("([Ljava.lang.String;)V", 22); + Utf8Const* main_name = _Jv_makeUtf8Const ("main", 4); + +#if 0 + // Note: this turns out to be more painful than useful. Apparently + // many people rely on being able to have main in a non-public + // class. + // This is based on my reading of 12.3.3. + if (! java::lang::reflect::Modifier::isPublic(klass->getModifiers())) + DIE ("class must be public"); +#endif + + _Jv_Method *meth = _Jv_GetMethodLocal (klass, main_name, main_signature); + + // Some checks from Java Spec section 12.1.4. + if (meth == NULL) + DIE ("no suitable method `main' in class"); + if (! java::lang::reflect::Modifier::isStatic(meth->accflags)) + DIE ("`main' must be static"); + if (! java::lang::reflect::Modifier::isPublic(meth->accflags)) + DIE ("`main' must be public"); + + main_func *real_main = (main_func *) meth->ncode; + (*real_main) (args); +} diff --git a/libjava/java/lang/natFloat.cc b/libjava/java/lang/natFloat.cc new file mode 100644 index 00000000000..e3189bebc2d --- /dev/null +++ b/libjava/java/lang/natFloat.cc @@ -0,0 +1,37 @@ +// natFloat.cc - Implementation of java.lang.Float native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include + +union u +{ + jint l; + jfloat d; +}; + +jint +java::lang::Float::floatToIntBits(jfloat value) +{ + union u u; + u.d = value; + return u.l; +} + +jfloat +java::lang::Float::intBitsToFloat(jint bits) +{ + union u u; + u.l = bits; + return u.d; +} + diff --git a/libjava/java/lang/natMath.cc b/libjava/java/lang/natMath.cc new file mode 100644 index 00000000000..66382473eed --- /dev/null +++ b/libjava/java/lang/natMath.cc @@ -0,0 +1,263 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/** + * @author Andrew Haley + * @date Tue Sep 22 1998 */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "fdlibm.h" + +jdouble java::lang::Math::cos(jdouble x) +{ + return (jdouble)::cos((double)x); +} + +jdouble java::lang::Math::sin(jdouble x) +{ + return (jdouble)::sin((double)x); +} + +jdouble java::lang::Math::tan(jdouble x) +{ + return (jdouble)::tan((double)x); +} + +jdouble java::lang::Math::asin(jdouble x) +{ + return (jdouble)::asin((double)x); +} + +jdouble java::lang::Math::acos(jdouble x) +{ + return (jdouble)::acos((double)x); +} + +jdouble java::lang::Math::atan(jdouble x) +{ + return (jdouble)::atan((double)x); +} + +jdouble java::lang::Math::atan2(jdouble y, jdouble x) +{ + return (jdouble)::atan2((jdouble)y, (jdouble)x); +} + +jdouble java::lang::Math::log(jdouble x) +{ + return (jdouble)::log((double)x); +} + +jdouble java::lang::Math::exp(jdouble x) +{ + return (jdouble)::exp((double)x); +} + +jdouble java::lang::Math::sqrt(jdouble x) +{ + return (jdouble)::sqrt((double)x); +} + +jdouble java::lang::Math::pow(jdouble y, jdouble x) +{ + return (jdouble)::pow((jdouble)y, (jdouble)x); +} + +jdouble java::lang::Math::IEEEremainder(jdouble y, jdouble x) +{ + return (jdouble)::__ieee754_remainder((jdouble)y, (jdouble)x); +} + +jdouble java::lang::Math::abs(jdouble x) +{ + return (jdouble)::fabs((double)x); +} + +jfloat java::lang::Math::abs(jfloat x) +{ + return (jfloat)::fabsf((float)x); +} + +jdouble java::lang::Math::rint(jdouble x) +{ + return (jdouble)::rint((double)x); +} + +jint java::lang::Math::round(jfloat x) +{ + if (x != x) + return 0; + if (x <= (jfloat)java::lang::Integer::MIN_VALUE) + return java::lang::Integer::MIN_VALUE; + if (x >= (jfloat)java::lang::Integer::MAX_VALUE) + return java::lang::Integer::MAX_VALUE; + + return (jint)::rintf((float)x); +} + +jlong java::lang::Math::round(jdouble x) +{ + if (x != x) + return 0; + if (x <= (jdouble)java::lang::Long::MIN_VALUE) + return java::lang::Long::MIN_VALUE; + if (x >= (jdouble)java::lang::Long::MAX_VALUE) + return java::lang::Long::MAX_VALUE; + + return (jlong)::rint((double)x); +} + +jdouble java::lang::Math::floor(jdouble x) +{ + return (jdouble)::floor((double)x); +} + +jdouble java::lang::Math::ceil(jdouble x) +{ + return (jdouble)::ceil((double)x); +} + +static inline int +floatToIntBits (jfloat value) +{ + union { + jint l; + jfloat d; + } u; + u.d = value; + return u.l; +} + +static inline bool +isNaN (jint bits) +{ + jint e = bits & 0x7f800000; + jint f = bits & 0x007fffff; + + return e == 0x7f800000 && f != 0; +} + +jfloat +java::lang::Math::min(jfloat a, jfloat b) +{ + jint abits = floatToIntBits (a); + jint bbits = floatToIntBits (b); + + if (isNaN (abits) || isNaN (bbits)) + return java::lang::Float::NaN; + + if (abits >= 0) // a is +ve + return bbits < 0 ? b // a is +ve, b is -ve. + // a and b are both +ve, so compare magnitudes: the number with + // the smallest magnitude is the smallest + : (abits < bbits ? a : b); + else // a is -ve + return bbits >= 0 ? a // a is -ve, b is +ve. + // a and b are both -ve, so compare magnitudes: the number with + // the biggest magnitude is the smallest + : (abits > bbits ? a : b); +} + +jfloat +java::lang::Math::max(jfloat a, jfloat b) +{ + jint abits = floatToIntBits (a); + jint bbits = floatToIntBits (b); + + if (isNaN (abits) || isNaN (bbits)) + return java::lang::Float::NaN; + + if (abits >= 0) // a is +ve + return bbits < 0 ? a // a is +ve, b is -ve. + // a and b are both +ve, so compare magnitudes: the number with + // the smallest magnitude is the smallest + : (abits > bbits ? a : b); + else // a is -ve + return bbits >= 0 ? b // a is -ve, b is +ve. + // a and b are both -ve, so compare magnitudes: the number with + // the biggest magnitude is the smallest + : (abits < bbits ? a : b); +} + +static inline jlong +doubleToLongBits (jdouble value) +{ + union { + jlong l; + jdouble d; + } u; + u.d = value; + return u.l; +} + +static inline bool +isNaN (jlong bits) +{ + jlong e = bits & 0x7ff0000000000000LL; + jlong f = bits & 0x000fffffffffffffLL; + + return e == 0x7ff0000000000000LL && f != 0LL; +} + + +jdouble +java::lang::Math::min(jdouble a, jdouble b) +{ + jlong abits = doubleToLongBits (a); + jlong bbits = doubleToLongBits (b); + + if (isNaN (abits) || isNaN (bbits)) + return java::lang::Double::NaN; + + if (abits >= 0LL) // a is +ve + return bbits < 0LL ? b // a is +ve, b is -ve. + // a and b are both +ve, so compare magnitudes: the number with + // the smallest magnitude is the smallest + : (abits < bbits ? a : b); + else // a is -ve + return bbits >= 0LL ? a // a is -ve, b is +ve. + // a and b are both -ve, so compare magnitudes: the number with + // the biggest magnitude is the smallest + : (abits > bbits ? a : b); +} + +jdouble +java::lang::Math::max(jdouble a, jdouble b) +{ + jlong abits = doubleToLongBits (a); + jlong bbits = doubleToLongBits (b); + + if (isNaN (abits) || isNaN (bbits)) + return java::lang::Double::NaN; + + if (abits >= 0LL) // a is +ve + return bbits < 0LL ? a // a is +ve, b is -ve. + // a and b are both +ve, so compare magnitudes: the number with + // the smallest magnitude is the smallest + : (abits > bbits ? a : b); + else // a is -ve + return bbits >= 0LL ? b // a is -ve, b is +ve. + // a and b are both -ve, so compare magnitudes: the number with + // the biggest magnitude is the smallest + : (abits < bbits ? a : b); +} + diff --git a/libjava/java/lang/natObject.cc b/libjava/java/lang/natObject.cc new file mode 100644 index 00000000000..7b26769e351 --- /dev/null +++ b/libjava/java/lang/natObject.cc @@ -0,0 +1,241 @@ +// natObject.cc - Implementation of the Object class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include + +#pragma implementation "Object.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define CloneableClass _CL_Q34java4lang9Cloneable +extern java::lang::Class CloneableClass; + + + +// This is used to represent synchronization information. +struct _Jv_SyncInfo +{ +#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) + // We only need to keep track of initialization state if we can + // possibly finalize this object. + bool init; +#endif + _Jv_ConditionVariable_t condition; + _Jv_Mutex_t mutex; +}; + + + +jclass +java::lang::Object::getClass (void) +{ + _Jv_VTable **dt = (_Jv_VTable **) this; + return (*dt)->clas; +} + +jint +java::lang::Object::hashCode (void) +{ + return _Jv_HashCode (this); +} + +jobject +java::lang::Object::clone (void) +{ + jclass klass = getClass (); + jobject r; + jint size; + + // We also clone arrays here. If we put the array code into + // __JArray, then we'd have to figure out a way to find the array + // vtbl when creating a new array class. This is easier, if uglier. + if (klass->isArray()) + { + __JArray *array = (__JArray *) this; + jclass comp = getClass()->getComponentType(); + jint eltsize; + if (comp->isPrimitive()) + { + r = _Jv_NewPrimArray (comp, array->length); + eltsize = comp->size(); + } + else + { + r = _Jv_NewObjectArray (array->length, comp, NULL); + eltsize = sizeof (jobject); + } + size = sizeof (__JArray) + array->length * eltsize; + } + else + { + if (! CloneableClass.isAssignableFrom(klass)) + JvThrow (new CloneNotSupportedException); + + size = klass->size(); + r = JvAllocObject (klass, size); + } + + memcpy ((void *) r, (void *) this, size); + return r; +} + + +// +// Synchronization code. +// + +// This global is used to make sure that only one thread sets an +// object's `sync_info' field. +static _Jv_Mutex_t sync_mutex; + +// This macro is used to see if synchronization initialization is +// needed. +#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) +# define INIT_NEEDED(Obj) (! (Obj)->sync_info \ + || ! ((_Jv_SyncInfo *) ((Obj)->sync_info))->init) +#else +# define INIT_NEEDED(Obj) (! (Obj)->sync_info) +#endif + +#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) +// If we have to run a destructor for a sync_info member, then this +// function is registered as a finalizer for the sync_info. +static void +finalize_sync_info (jobject obj) +{ + _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj; +#if defined (_Jv_HaveCondDestroy) + _Jv_CondDestroy (&si->condition); +#endif +#if defined (_Jv_HaveMutexDestroy) + _Jv_MutexDestroy (&si->mutex); +#endif + si->init = false; +} +#endif + +// This is called to initialize the sync_info element of an object. +void +java::lang::Object::sync_init (void) +{ + _Jv_MutexLock (&sync_mutex); + // Check again to see if initialization is needed now that we have + // the lock. + if (INIT_NEEDED (this)) + { + // We assume there are no pointers in the sync_info + // representation. + _Jv_SyncInfo *si; + // We always create a new sync_info, even if there is already + // one available. Any given object can only be finalized once. + // If we get here and sync_info is not null, then it has already + // been finalized. So if we just reinitialize the old one, + // we'll never be able to (re-)destroy the mutex and/or + // condition variable. + si = (_Jv_SyncInfo *) _Jv_AllocBytes (sizeof (_Jv_SyncInfo)); + // FIXME: what if si == NULL? + _Jv_MutexInit (&si->mutex); + _Jv_CondInit (&si->condition); +#if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) + // Register a finalizer. + si->init = true; + _Jv_RegisterFinalizer (si, finalize_sync_info); +#endif + sync_info = (jobject) si; + } + _Jv_MutexUnlock (&sync_mutex); +} + +void +java::lang::Object::notify (void) +{ + if (INIT_NEEDED (this)) + sync_init (); + _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info; + if (_Jv_CondNotify (&si->condition, &si->mutex)) + JvThrow (new IllegalMonitorStateException); +} + +void +java::lang::Object::notifyAll (void) +{ + if (INIT_NEEDED (this)) + sync_init (); + _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info; + if (_Jv_CondNotifyAll (&si->condition, &si->mutex)) + JvThrow (new IllegalMonitorStateException); +} + +void +java::lang::Object::wait (jlong timeout, jint nanos) +{ + if (INIT_NEEDED (this)) + sync_init (); + if (timeout < 0 || nanos < 0 || nanos > 999999) + JvThrow (new IllegalArgumentException); + _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info; + if (_Jv_CondWait (&si->condition, &si->mutex, timeout, nanos)) + JvThrow (new IllegalMonitorStateException); + if (Thread::interrupted()) + JvThrow (new InterruptedException); +} + +// +// Some runtime code. +// + +// This function is called at system startup to initialize the +// `sync_mutex'. +void +_Jv_InitializeSyncMutex (void) +{ + _Jv_MutexInit (&sync_mutex); +} + +jint +_Jv_MonitorEnter (jobject obj) +{ + if (! obj) + JvThrow (new java::lang::NullPointerException); + if (INIT_NEEDED (obj)) + obj->sync_init (); + _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj->sync_info; + return _Jv_MutexLock (&si->mutex); +} + +jint +_Jv_MonitorExit (jobject obj) +{ + JvAssert (obj); + JvAssert (! INIT_NEEDED (obj)); + _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj->sync_info; + if (_Jv_MutexUnlock (&si->mutex)) + JvThrow (new java::lang::IllegalMonitorStateException); + return 0; +} + +void +_Jv_FinalizeObject (jobject obj) +{ + java::lang::Object::hack12_6(obj); +} diff --git a/libjava/java/lang/natRuntime.cc b/libjava/java/lang/natRuntime.cc new file mode 100644 index 00000000000..d89ab18bd9c --- /dev/null +++ b/libjava/java/lang/natRuntime.cc @@ -0,0 +1,68 @@ +// natRuntime.cc - Implementation of native side of Runtime class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include + +#include +#include +#include + +void +java::lang::Runtime::exit (jint status) +{ + checkExit (status); + + // Make status right for Unix. This is perhaps strange. + if (status < 0 || status > 255) + status = 255; + + if (finalize_on_exit) + _Jv_RunAllFinalizers (); + + ::exit (status); +} + +jlong +java::lang::Runtime::freeMemory (void) +{ + return _Jv_GCFreeMemory (); +} + +void +java::lang::Runtime::gc (void) +{ + _Jv_RunGC (); +} + +void +java::lang::Runtime::runFinalization (void) +{ + _Jv_RunFinalizers (); +} + +jlong +java::lang::Runtime::totalMemory (void) +{ + return _Jv_GCTotalMemory (); +} + +void +java::lang::Runtime::traceInstructions (jboolean) +{ + // Do nothing. +} + +void +java::lang::Runtime::traceMethodCalls (jboolean) +{ + // Do nothing. +} diff --git a/libjava/java/lang/natString.cc b/libjava/java/lang/natString.cc new file mode 100644 index 00000000000..5cb7b2c72b4 --- /dev/null +++ b/libjava/java/lang/natString.cc @@ -0,0 +1,800 @@ +// natString.cc - Implementation of java.lang.String native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static jstring* strhash = NULL; +static int strhash_count = 0; /* Number of slots used in strhash. */ +static int strhash_size = 0; /* Number of slots available in strhash. + * Assumed be power of 2! */ + +#define DELETED_STRING ((jstring)(~0)) +#define SET_STRING_IS_INTERNED(STR) /* nothing */ + +/* Find a slot where the string with elements DATA, length LEN, + and hash HASH should go in the strhash table of interned strings. */ +jstring* +_Jv_StringFindSlot (jchar* data, jint len, jint hash) +{ + JvSynchronize sync (&StringClass); + + int start_index = hash & (strhash_size - 1); + int deleted_index = -1; + + register int index = start_index; + /* step must be non-zero, and relatively prime with strhash_size. */ + int step = 8 * hash + 7; + for (;;) + { + register jstring* ptr = &strhash[index]; + if (*ptr == NULL) + { + if (deleted_index >= 0) + return (&strhash[deleted_index]); + else + return ptr; + } + else if (*ptr == DELETED_STRING) + deleted_index = index; + else if ((*ptr)->length() == len + && memcmp(JvGetStringChars(*ptr), data, 2*len) == 0) + return (ptr); + index = (index + step) & (strhash_size - 1); + JvAssert (index != start_index); + } +} + +/* Calculate a hash code for the string starting at PTR at given LENGTH. + This uses the same formula as specified for java.lang.String.hash. */ + +static jint +hashChars (jchar* ptr, jint length) +{ + register jchar* limit = ptr + length; + jint hash = 0; + // Updated specification from + // http://www.javasoft.com/docs/books/jls/clarify.html. + while (ptr < limit) + hash = (31 * hash) + *ptr++; + return hash; +} + +jint +java::lang::String::hashCode() +{ + return hashChars(JvGetStringChars(this), length()); +} + +jstring* +_Jv_StringGetSlot (jstring str) +{ + jchar* data = JvGetStringChars(str); + int length = str->length(); + return _Jv_StringFindSlot(data, length, hashChars (data, length)); +} + +void +java::lang::String::rehash() +{ + JvSynchronize sync (&StringClass); + + if (strhash == NULL) + { + strhash_size = 1024; + strhash = (jstring *) _Jv_AllocBytes (strhash_size * sizeof (jstring)); + memset (strhash, 0, strhash_size * sizeof (jstring)); + } + else + { + register int i = strhash_size; + register jstring* ptr = strhash + i; + strhash_size *= 2; + strhash = (jstring *) _Jv_AllocBytes (strhash_size * sizeof (jstring)); + memset (strhash, 0, strhash_size * sizeof (jstring)); + + while (--i >= 0) + { + --ptr; + if (*ptr == NULL || *ptr == DELETED_STRING) + continue; + + /* This is faster equivalent of + * *__JvGetInternSlot(*ptr) = *ptr; */ + jint hash = (*ptr)->hashCode(); + jint index = hash & (strhash_size - 1); + jint step = 8 * hash + 7; + for (;;) + { + if (strhash[index] == NULL) + { + strhash[index] = *ptr; + break; + } + index = (index + step) & (strhash_size - 1); + } + } + } +} + +jstring +java::lang::String::intern() +{ + JvSynchronize sync (&StringClass); + if (4 * strhash_count >= 3 * strhash_size) + rehash(); + jstring* ptr = _Jv_StringGetSlot(this); + if (*ptr != NULL && *ptr != DELETED_STRING) + return *ptr; + SET_STRING_IS_INTERNED(this); + strhash_count++; + *ptr = this; + return this; +} + +/* Called by String fake finalizer. */ +void +java::lang::String::unintern() +{ + JvSynchronize sync (&StringClass); + jstring* ptr = _Jv_StringGetSlot(this); + if (*ptr == NULL || *ptr == DELETED_STRING) + return; + *ptr = DELETED_STRING; + strhash_count--; +} + +jstring +_Jv_NewStringUTF (const char *bytes) +{ + int size = strlen (bytes); + unsigned char *p = (unsigned char *) bytes; + + int length = _Jv_strLengthUtf8 ((char *) p, size); + if (length < 0) + return NULL; + + jstring jstr = JvAllocString (length); + jchar *chrs = JvGetStringChars (jstr); + + p = (unsigned char *) bytes; + unsigned char *limit = p + size; + while (p < limit) + *chrs++ = UTF8_GET (p, limit); + + return jstr; +} + +jstring +_Jv_NewStringUtf8Const (Utf8Const* str) +{ + jchar *chrs; + jchar buffer[100]; + jstring jstr; + register unsigned char* data = (unsigned char*) str->data; + register unsigned char* limit = data + str->length; + int length = _Jv_strLengthUtf8(str->data, str->length); + + if (length <= (int) (sizeof(buffer) / sizeof(jchar))) + { + jstr = NULL; + chrs = buffer; + } + else + { + jstr = JvAllocString(length); + chrs = JvGetStringChars(jstr); + } + + while (data < limit) + *chrs++ = UTF8_GET(data, limit); + chrs -= length; + + JvSynchronize sync (&StringClass); + if (4 * strhash_count >= 3 * strhash_size) + java::lang::String::rehash(); + int hash = str->hash; + jstring* ptr = _Jv_StringFindSlot (chrs, length, hash); + if (*ptr != NULL && *ptr != DELETED_STRING) + return *ptr; + strhash_count++; + if (jstr == NULL) + { + jstr = JvAllocString(length); + chrs = JvGetStringChars(jstr); + memcpy (chrs, buffer, sizeof(jchar)*length); + } + *ptr = jstr; + SET_STRING_IS_INTERNED(jstr); + return jstr; +} + +jsize +_Jv_GetStringUTFLength (jstring string) +{ + register jsize len = 0; + register jchar *ptr = JvGetStringChars (string); + register jsize i = string->length(); + while (--i >= 0) + { + register jchar ch = *ptr++; + if (ch > 0 && ch <= 0x7F) + len += 1; + else if (ch <= 0x7FF) + len += 2; + else + len += 3; + } + return len; +} + +// Not sure this quite matches GetStringUTFRegion. +// null-termination of result? len? throw exception? +jsize +_Jv_GetStringUTFRegion (jstring str, jsize start, jsize len, char *buf) +{ + register jchar *sptr = JvGetStringChars (str) + start; + register jsize i = len; + register char *dptr = buf; + while (--i >= 0) + { + jchar ch = *sptr++; + if (ch > 0 && ch <= 0x7F) + *dptr++ = (char) ch; + else if (ch <= 0x7FF) + { + *dptr++ = (char) (0xC0 + ((ch >> 6) & 0x1F)); + *dptr++ = (char) (0x80 + (ch & 0x3F)); + } + else + { + *dptr++ = (char) (0xE0 + ((ch >> 12) & 0xF)); + *dptr++ = (char) (0x80 + ((ch >> 6) & 0x3F)); + *dptr++ = (char) (0x80 + (ch & 0x3F)); + } + } + return dptr - buf; +} + +jstring +_Jv_AllocString(jsize len) +{ + jsize sz = sizeof(java::lang::String) + len * sizeof(jchar); + + jstring obj = (jstring) JvAllocObject(&StringClass, sz); + + obj->data = obj; + obj->boffset = sizeof(java::lang::String); + obj->count = len; + return obj; +} + +jstring +_Jv_NewString(const jchar *chars, jsize len) +{ + jstring str = _Jv_AllocString(len); + jchar* data = JvGetStringChars (str); + while (--len >= 0) + *data++ = *chars++; + return str; +} + +jstring +_Jv_NewStringLatin1(const char *bytes, jsize len) +{ + jstring str = JvAllocString(len); + jchar* data = JvGetStringChars (str); + while (--len >= 0) + *data++ = *(unsigned char*)bytes++; + return str; +} + +void +java::lang::String::init () +{ + count = 0; + boffset = sizeof(java::lang::String); + data = this; +} + +void +java::lang::String::init(jcharArray chars, jint offset, jint count, + jboolean dont_copy) +{ + if (! chars) + JvThrow (new NullPointerException); + jsize data_size = JvGetArrayLength (chars); + if (offset < 0 || count < 0 || offset + count > data_size) + JvThrow (new StringIndexOutOfBoundsException()); + jcharArray array; + jchar *pdst; + if (! dont_copy) + { + array = JvNewCharArray(count); + pdst = elements (array); + memcpy (pdst, elements (chars) + offset, count * sizeof (jchar)); + } + else + { + JvAssert (offset == 0); + array = chars; + pdst = elements (array); + } + + data = array; + boffset = (char *) pdst - (char *) array; + this->count = count; +} + +void +java::lang::String::init(jbyteArray ascii, jint hibyte, jint offset, + jint count) +{ + if (! ascii) + JvThrow (new NullPointerException); + jsize data_size = JvGetArrayLength (ascii); + if (offset < 0 || count < 0 || offset + count < 0 + || offset + count > data_size) + JvThrow (new java::lang::StringIndexOutOfBoundsException()); + jcharArray array = JvNewCharArray(count); + jbyte *psrc = elements (ascii) + offset; + jchar *pdst = elements (array); + data = array; + boffset = (char *) pdst - (char *) array; + this->count = count; + hibyte = (hibyte & 0xff) << 8; + while (-- count >= 0) + { + *pdst++ = hibyte | (*psrc++ & 0xff); + } +} + +void +java::lang::String::init (jbyteArray bytes, jint offset, jint count, + jstring encoding) +{ + if (! bytes) + JvThrow (new NullPointerException); + jsize data_size = JvGetArrayLength (bytes); + if (offset < 0 || count < 0 || offset + count < 0 + || offset + count > data_size) + JvThrow (new StringIndexOutOfBoundsException); + + java::io::ByteArrayInputStream *b + = new java::io::ByteArrayInputStream (bytes, offset, count); + java::io::InputStreamReader *ir + = new java::io::InputStreamReader (b, encoding); + // FIXME: we allocate too much here in some cases. + jcharArray array = JvNewCharArray (count); + data = array; + boffset = (char *) elements (array) - (char *) array; + // FIXME: this can throw IOException. + this->count = ir->read(array, 0, count); +} + +jboolean +java::lang::String::equals(jobject anObject) +{ + if (anObject == NULL) + return false; + if (anObject == this) + return true; + if (anObject->getClass() != &StringClass) + return false; + jstring other = (jstring) anObject; + if (count != other->count) + return false; + /* if both are interned, return false. */ + register jint i = count; + register jchar *xptr = JvGetStringChars (this); + register jchar *yptr = JvGetStringChars (other); + while (--i >= 0) + { + if (*xptr++ != *yptr++) + return false; + } + return true; +} + +jchar +java::lang::String::charAt(jint i) +{ + if (i < 0 || i >= count) + JvThrow (new java::lang::StringIndexOutOfBoundsException()); + return JvGetStringChars(this)[i]; +} + +void +java::lang::String::getChars(jint srcBegin, jint srcEnd, + jcharArray dst, jint dstBegin) +{ + jint dst_length = JvGetArrayLength (dst); + if (srcBegin < 0 || srcBegin > srcEnd || srcEnd > count + || dstBegin < 0 || dstBegin + (srcEnd-srcBegin) > dst_length) + JvThrow (new java::lang::ArrayIndexOutOfBoundsException()); + register jchar *dPtr = elements (dst) + dstBegin; + register jchar *sPtr = JvGetStringChars (this) + srcBegin; + register jint i = srcEnd-srcBegin; + while (--i >= 0) + *dPtr++ = *sPtr++; +} + +jbyteArray +java::lang::String::getBytes (jstring enc) +{ + java::io::ByteArrayOutputStream *os + = new java::io::ByteArrayOutputStream(length ()); + java::io::OutputStreamWriter *ow + = new java::io::OutputStreamWriter(os, enc); + + ow->write(this, 0, length ()); + ow->flush(); + + return os->toByteArray(); +} + +void +java::lang::String::getBytes(jint srcBegin, jint srcEnd, + jbyteArray dst, jint dstBegin) +{ + jint dst_length = JvGetArrayLength (dst); + if (srcBegin < 0 || srcBegin > srcEnd || srcEnd > count + || dstBegin < 0 || dstBegin + (srcEnd-srcBegin) > dst_length) + JvThrow (new java::lang::ArrayIndexOutOfBoundsException()); + register jbyte *dPtr = elements (dst) + dstBegin; + register jchar *sPtr = JvGetStringChars (this) + srcBegin; + register jint i = srcEnd-srcBegin; + while (--i >= 0) + *dPtr++ = (jbyte) *sPtr++; +} + +jcharArray +java::lang::String::toCharArray() +{ + jcharArray array = JvNewCharArray(count); + register jchar *dPtr = elements (array); + register jchar *sPtr = JvGetStringChars (this); + register jint i = count; + while (--i >= 0) + *dPtr++ = *sPtr++; + return array; +} + +jboolean +java::lang::String::equalsIgnoreCase (jstring anotherString) +{ + if (count != anotherString->count) + return false; + register jchar *tptr = JvGetStringChars (this); + register jchar *optr = JvGetStringChars (anotherString); + register jint i = count; + while (--i >= 0) + { + jchar tch = *tptr++; + jchar och = *optr++; + if (tch != och + && (java::lang::Character::toLowerCase (tch) + != java::lang::Character::toLowerCase (och)) + && (java::lang::Character::toUpperCase (tch) + != java::lang::Character::toUpperCase (och))) + return false; + } + return true; +} + +jboolean +java::lang::String::regionMatches (jint toffset, + jstring other, jint ooffset, jint len) +{ + if (toffset < 0 || ooffset < 0 + || toffset + len > count + || ooffset + len > other->count) + return false; + register jchar *tptr = JvGetStringChars (this) + toffset; + register jchar *optr = JvGetStringChars (other) + ooffset; + register jint i = len; + while (--i >= 0) + { + if (*tptr++ != *optr++) + return false; + } + return true; +} + +jint +java::lang::String::compareTo (jstring anotherString) +{ + register jchar *tptr = JvGetStringChars (this); + register jchar *optr = JvGetStringChars (anotherString); + jint tlen = this->count; + jint olen = anotherString->count; + register jint i = tlen > olen ? olen : tlen; + while (--i >= 0) + { + jchar tch = *tptr++; + jchar och = *optr++; + if (tch != och) + return (jint) tch - (jint) och; + } + return tlen - olen; +} + +jboolean +java::lang::String::regionMatches (jboolean ignoreCase, jint toffset, + jstring other, jint ooffset, jint len) +{ + if (toffset < 0 || ooffset < 0 + || toffset + len > count + || ooffset + len > other->count) + return false; + register jchar *tptr = JvGetStringChars (this) + toffset; + register jchar *optr = JvGetStringChars (other) + ooffset; + register jint i = len; + while (--i >= 0) + { + jchar tch = *tptr++; + jchar och = *optr++; + if (tch != och) + return false; + if (ignoreCase + && (java::lang::Character::toLowerCase (tch) + != java::lang::Character::toLowerCase (och)) + && (java::lang::Character::toUpperCase (tch) + != java::lang::Character::toUpperCase (och))) + return false; + } + return true; +} + +jboolean +java::lang::String::startsWith (jstring prefix, jint toffset) +{ + register jint i = prefix->count; + if (toffset < 0 || toffset + i > count) + return false; + register jchar *xptr = JvGetStringChars (this) + toffset; + register jchar *yptr = JvGetStringChars (prefix); + while (--i >= 0) + { + if (*xptr++ != *yptr++) + return false; + } + return true; +} + +jint +java::lang::String::indexOf (jint ch, jint fromIndex) +{ + if (fromIndex < 0) + fromIndex = 0; + register jchar *ptr = JvGetStringChars(this); + for (;; ++fromIndex) + { + if (fromIndex >= count) + return -1; + if (ptr[fromIndex] == ch) + return fromIndex; + } +} + +jint +java::lang::String::indexOf (jstring s, jint fromIndex) +{ + const jchar *const xchars = JvGetStringChars(s); + const jchar *const ychars = JvGetStringChars(this) + fromIndex; + + const int xlength = s->length (); + const int ylength = length () - fromIndex; + + int i = 0; + int j = 0; + + while (i < ylength && j < xlength) + { + if (xchars[j] != ychars[i]) + { + i = i - j + 1; + j = 0; + } + else + i++, j++; + } + + if (j >= xlength) + return fromIndex + i - xlength; + else + return -1; +} + +jint +java::lang::String::lastIndexOf (jint ch, jint fromIndex) +{ + if (fromIndex >= count) + fromIndex = count - 1; + register jchar *ptr = JvGetStringChars(this); + for (;; --fromIndex) + { + if (fromIndex < 0) + return -1; + if (ptr[fromIndex] == ch) + return fromIndex; + } +} + +jstring +java::lang::String::substring (jint beginIndex, jint endIndex) +{ + if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) + JvThrow (new StringIndexOutOfBoundsException()); + jint newCount = endIndex - beginIndex; + if (newCount <= 8) // Optimization, mainly for GC. + return JvNewString(JvGetStringChars(this) + beginIndex, newCount); + jstring s = new String(); + s->data = data; + s->count = newCount; + s->boffset = boffset + sizeof(jchar) * beginIndex; + return s; +} + +jstring +java::lang::String::concat(jstring str) +{ + jint str_count = str->count; + if (str_count == 0) + return this; + jstring result = JvAllocString(count + str_count); + register jchar *dstPtr = JvGetStringChars(result); + register jchar *srcPtr = JvGetStringChars(this); + register jint i = count; + while (--i >= 0) + *dstPtr++ = *srcPtr++; + srcPtr = JvGetStringChars(str); + i = str->count; + while (--i >= 0) + *dstPtr++ = *srcPtr++; + return result; +} + +jstring +java::lang::String::replace (jchar oldChar, jchar newChar) +{ + jint i; + jchar* chrs = JvGetStringChars (this); + for (i = 0; ; i++) + { + if (i == count) + return this; + if (chrs[i] == oldChar) + break; + } + jstring result = JvAllocString (count); + jchar *dPtr = JvGetStringChars (result); + for (int j = 0; j < i; j++) + *dPtr++ = chrs[j]; + for (; i < count; i++) + { + jchar ch = chrs[i]; + if (ch == oldChar) + ch = newChar; + *dPtr++ = ch; + } + return result; +} + +jstring +java::lang::String::toLowerCase () +{ + jint i; + jchar* chrs = JvGetStringChars(this); + jchar ch; + for (i = 0; ; i++) + { + if (i == count) + return this; + jchar origChar = chrs[i]; + ch = java::lang::Character::toLowerCase(origChar); + if (ch != origChar) + break; + } + jstring result = JvAllocString(count); + jchar *dPtr = JvGetStringChars (result); + for (int j = 0; j < i; j++) + *dPtr++ = chrs[j]; + *dPtr++ = ch; i++; + for (; i < count; i++) + { + *dPtr++ = java::lang::Character::toLowerCase(chrs[i]); + } + return result; +} + +jstring +java::lang::String::toUpperCase () +{ + jint i; + jchar* chrs = JvGetStringChars(this); + jchar ch; + for (i = 0; ; i++) + { + if (i == count) + return this; + jchar origChar = chrs[i]; + ch = java::lang::Character::toUpperCase(origChar); + if (ch != origChar) + break; + } + jstring result = JvAllocString(count); + jchar *dPtr = JvGetStringChars (result); + for (int j = 0; j < i; j++) + *dPtr++ = chrs[j]; + *dPtr++ = ch; i++; + for (; i < count; i++) + { + *dPtr++ = java::lang::Character::toUpperCase(chrs[i]); + } + return result; +} + +jstring +java::lang::String::trim () +{ + jchar* chrs = JvGetStringChars(this); + if (count == 0 || (chrs[0] > ' ' && chrs[count-1] > ' ')) + return this; + jint preTrim = 0; + for (;; preTrim++) + { + if (preTrim == count) + return new String(); + if (chrs[preTrim] > ' ') + break; + } + jint endTrim = count; + while (chrs[endTrim-1] <= ' ') + endTrim--; + return substring(preTrim, endTrim); +} + +jstring +java::lang::String::valueOf(jcharArray data, jint offset, jint count) +{ + jint data_length = JvGetArrayLength (data); + if (offset < 0 || count < 0 || offset+count > data_length) + JvThrow (new java::lang::IndexOutOfBoundsException()); + register jstring result = JvAllocString(count); + register jchar *sPtr = elements (data) + offset; + register jchar *dPtr = JvGetStringChars(result); + while (--count >= 0) + *dPtr++ = *sPtr++; + return result; +} + +jstring +java::lang::String::valueOf(jchar c) +{ + register jstring result = JvAllocString(1); + JvGetStringChars (result)[0] = c; + return result; +} diff --git a/libjava/java/lang/natSystem.cc b/libjava/java/lang/natSystem.cc new file mode 100644 index 00000000000..5f613d53ead --- /dev/null +++ b/libjava/java/lang/natSystem.cc @@ -0,0 +1,259 @@ +// natSystem.cc - Native code implementing System class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#ifdef HAVE_GETPWUID_R +#define _POSIX_PTHREAD_SEMANTICS +#ifndef _REENTRANT +#define _REENTRANT +#endif +#endif + +#include +#include +#include + +#ifdef HAVE_UNISTD_H +#include +#endif + +#ifdef HAVE_SYS_TIME_H +#include +#endif + +#ifdef HAVE_PWD_H +#include +#endif +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#if defined (ECOS) +extern "C" unsigned long long _clock (void); +#endif + +void +java::lang::System::setErr (java::io::PrintStream *newErr) +{ + checkSetIO (); + // This violates `final' semantics. Oh well. + err = newErr; +} + +void +java::lang::System::setIn (java::io::InputStream *newIn) +{ + checkSetIO (); + // This violates `final' semantics. Oh well. + in = newIn; +} + +void +java::lang::System::setOut (java::io::PrintStream *newOut) +{ + checkSetIO (); + // This violates `final' semantics. Oh well. + out = newOut; +} + +void +java::lang::System::arraycopy (jobject src, jint src_offset, + jobject dst, jint dst_offset, + jint count) +{ + if (! src || ! dst) + _Jv_Throw (new NullPointerException); + + jclass src_c = src->getClass(); + jclass dst_c = dst->getClass(); + jclass src_comp = src_c->getComponentType(); + jclass dst_comp = dst_c->getComponentType(); + + if (! src_c->isArray() || ! dst_c->isArray() + || src_comp->isPrimitive() != dst_comp->isPrimitive() + || (src_comp->isPrimitive() && src_comp != dst_comp)) + _Jv_Throw (new ArrayStoreException); + + __JArray *src_a = (__JArray *) src; + __JArray *dst_a = (__JArray *) dst; + if (src_offset < 0 || dst_offset < 0 || count < 0 + || src_offset + count > src_a->length + || dst_offset + count > dst_a->length) + _Jv_Throw (new ArrayIndexOutOfBoundsException); + + // Do-nothing cases. + if ((src == dst && src_offset == dst_offset) + || ! count) + return; + + // If both are primitive, we can optimize trivially. If DST + // components are always assignable from SRC components, then we + // will never need to raise an error, and thus can do the + // optimization. If source and destinations are the same, then we + // know that the assignability premise always holds. + const bool prim = src_comp->isPrimitive(); + if (prim || dst_comp->isAssignableFrom(src_comp) || src == dst) + { + const size_t size = prim ? src_comp->size() + : sizeof elements((jobjectArray)src)[0]; + + // We need a particular type to get the pointer to the data. So + // we choose bytes. + char *src_elts = (((char *) elements ((jbyteArray) src)) + + src_offset * size); + char *dst_elts = (((char *) elements ((jbyteArray) dst)) + + dst_offset * size); + // We don't bother trying memcpy. It can't be worth the cost of + // the check. + memmove ((void *) dst_elts, (void *) src_elts, count * size); + } + else + { + jobject *src_elts = elements ((jobjectArray) src_a) + src_offset; + jobject *dst_elts = elements ((jobjectArray) dst_a) + dst_offset; + + for (int i = 0; i < count; ++i) + { + if (*src_elts + && ! dst_comp->isAssignableFrom((*src_elts)->getClass())) + _Jv_Throw (new ArrayStoreException); + *dst_elts++ = *src_elts++; + } + } +} + +jlong +java::lang::System::currentTimeMillis (void) +{ + jlong r; + +#if defined (HAVE_GETTIMEOFDAY) + struct timeval tv; + gettimeofday (&tv, NULL); + r = (jlong) tv.tv_sec * 1000 + tv.tv_usec / 1000; +#elif defined (HAVE_TIME) + r = time (NULL) * 1000; +#elif defined (HAVE_FTIME) + struct timeb t; + ftime (&t); + r = t.time * 1000 + t.millitm; +#elif defined (ECOS) + r = _clock(); +#else + // In the absence of any function, time remains forever fixed. + r = 23; +#endif + + return r; +} + +jint +java::lang::System::identityHashCode (jobject obj) +{ + return _Jv_HashCode (obj); +} + +void +java::lang::System::init_properties (void) +{ + if (prop_init) + return; + prop_init = true; + + properties = new java::util::Properties (); + // A convenience define. +#define SET(Prop,Val) \ + properties->put(JvNewStringLatin1 (Prop), JvNewStringLatin1 (Val)) + SET ("java.version", "FIXME"); + SET ("java.vendor", "Cygnus Solutions"); + SET ("java.vendor.url", "http://www.cygnus.com/"); + // SET ("java.home", "FIXME"); + // SET ("java.class.version", "FIXME"); + // SET ("java.class.path", "FIXME"); + SET ("os.name", "FIXME"); + SET ("os.arch", "FIXME"); + SET ("os.version", "FIXME"); + SET ("file.encoding", "8859_1"); // FIXME +#ifdef WIN32 + SET ("file.separator", "\\"); + SET ("path.separator", ";"); + SET ("line.separator", "\r\n"); +#else + // Unix. + SET ("file.separator", "/"); + SET ("path.separator", ":"); + SET ("line.separator", "\n"); +#endif + +#ifdef HAVE_PWD_H + uid_t user_id = getuid (); + struct passwd *pwd_entry; + +#ifdef HAVE_GETPWUID_R + struct passwd pwd_r; + size_t len_r = 200; + char *buf_r = (char *) _Jv_AllocBytes (len_r); + + while (buf_r != NULL) + { + int r = getpwuid_r (user_id, &pwd_r, buf_r, len_r, &pwd_entry); + if (r == 0) + break; + else if (r != ERANGE) + { + pwd_entry = NULL; + break; + } + len_r *= 2; + buf_r = (char *) _Jv_AllocBytes (len_r); + } +#else + struct passwd *pwd_entry = getpwuid (user_id); +#endif /* HAVE_GETPWUID_R */ + + if (pwd_entry != NULL) + { + SET ("user.name", pwd_entry->pw_name); + SET ("user.home", pwd_entry->pw_dir); + } +#endif /* HAVE_PWD_H */ + +#ifdef HAVE_UNISTD_H + /* Use getcwd to set "user.dir". */ + int buflen = 250; + char *buffer = (char *) malloc (buflen); + while (buffer != NULL) + { + if (getcwd (buffer, buflen) != NULL) + { + SET ("user.dir", buffer); + break; + } + if (errno != ERANGE) + break; + buflen = 2 * buflen; + buffer = (char *) realloc (buffer, buflen); + } + if (buffer != NULL) + free (buffer); +#endif +} diff --git a/libjava/java/lang/natThread.cc b/libjava/java/lang/natThread.cc new file mode 100644 index 00000000000..117191133a8 --- /dev/null +++ b/libjava/java/lang/natThread.cc @@ -0,0 +1,295 @@ +// natThread.cc - Native part of Thread class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + + + +// This structure is used to represent all the data the native side +// needs. An object of this type is assigned to the `data' member of +// the Thread class. +struct natThread +{ + // These are used to interrupt sleep and join calls. We can share a + // condition variable here since this thread can either be sleeping + // or waiting for a thread exit, but not both. + _Jv_Mutex_t interrupt_mutex; + _Jv_ConditionVariable_t interrupt_cond; + + // This is private data for the thread system layer. + _Jv_Thread_t *thread; + + // All threads waiting to join this thread are linked together and + // waiting on their respective `interrupt' condition variables. + // When this thread exits, it notifies each such thread by + // signalling the condition. In this case the `interrupt_flag' is + // not set; this is how the waiting thread knows whether the join + // has failed or whether it should throw an exception. + struct natThread *joiner; + + // Chain for waiters. + struct natThread *next; +}; + +// This is called from the constructor to initialize the native side +// of the Thread. +void +java::lang::Thread::initialize_native (void) +{ + // FIXME: this must interact with the GC in some logical way. At + // the very least we must register a finalizer to clean up. This + // isn't easy to do. If the Thread object resurrects itself in its + // own finalizer then we will need to reinitialize this structure at + // any "interesting" point. + natThread *nt = (natThread *) _Jv_AllocBytes (sizeof (natThread)); + data = (jobject) nt; + _Jv_MutexInit (&nt->interrupt_mutex); + _Jv_CondInit (&nt->interrupt_cond); + _Jv_ThreadInitData (&nt->thread, this); + nt->joiner = 0; + nt->next = 0; +} + +jint +java::lang::Thread::countStackFrames (void) +{ + // NOTE: This is deprecated in JDK 1.2. + JvFail ("java::lang::Thread::countStackFrames unimplemented"); + return 0; +} + +java::lang::Thread * +java::lang::Thread::currentThread (void) +{ + return _Jv_ThreadCurrent (); +} + +// FIXME: this is apparently the only way a thread can be removed from +// a ThreadGroup. That seems wrong. +void +java::lang::Thread::destroy (void) +{ + // NOTE: This is marked as unimplemented in the JDK 1.2 + // documentation. + JvFail ("java::lang::Thread::destroy unimplemented"); +} + +void +java::lang::Thread::dumpStack (void) +{ + // We don't implement this because it is very hard. Once we have a + // VM, this could potentially ask the VM to do the dump in cases + // where it makes sense. + JvFail ("java::lang::Thread::dumpStack unimplemented"); +} + +void +java::lang::Thread::interrupt (void) +{ + interrupt_flag = true; + + // Wake up this thread, whether it is sleeping or waiting for + // another thread to exit. + natThread *nt = (natThread *) data; + _Jv_MutexLock (&nt->interrupt_mutex); + _Jv_CondNotify (&nt->interrupt_cond, &nt->interrupt_mutex); + _Jv_MutexUnlock (&nt->interrupt_mutex); + + _Jv_ThreadInterrupt (nt->thread); +} + +void +java::lang::Thread::join (jlong millis, jint nanos) +{ + // FIXME: what if we are trying to join ourselves with no timeout? + + if (millis < 0 || nanos < 0 || nanos > 999999) + _Jv_Throw (new IllegalArgumentException); + + Thread *current = currentThread (); + if (current->isInterrupted ()) + _Jv_Throw (new InterruptedException); + + // Update the list of all threads waiting for this thread to exit. + // We grab a mutex when doing this in order to ensure that the + // required state changes are atomic. + _Jv_MonitorEnter (this); + if (! isAlive ()) + { + _Jv_MonitorExit (this); + return; + } + + // Here `CURR_NT' is the native structure for the currently + // executing thread, while `NT' is the native structure for the + // thread we are trying to join. + natThread *curr_nt = (natThread *) current->data; + natThread *nt = (natThread *) data; + + JvAssert (curr_nt->next == NULL); + // Put thread CURR_NT onto NT's list. When NT exits, it will + // traverse its list and notify all joiners. + curr_nt->next = nt->joiner; + nt->joiner = curr_nt; + _Jv_MonitorExit (this); + + + // Now wait for: (1) an interrupt, (2) the thread to exit, or (3) + // the timeout to occur. + _Jv_MutexLock (&curr_nt->interrupt_mutex); + _Jv_CondWait (&curr_nt->interrupt_cond, + &curr_nt->interrupt_mutex, + millis, nanos); + _Jv_MutexUnlock (&curr_nt->interrupt_mutex); + + // Now the join has completed, one way or another. Update the + // joiners list to account for this. + _Jv_MonitorEnter (this); + JvAssert (nt->joiner != NULL); + natThread *prev = 0; + natThread *t; + for (t = nt->joiner; t != NULL; t = t->next) + { + if (t == curr_nt) + { + if (prev) + prev->next = t->next; + else + nt->joiner = t->next; + t->next = 0; + break; + } + } + JvAssert (t != NULL); + _Jv_MonitorExit (this); + + if (current->isInterrupted ()) + _Jv_Throw (new InterruptedException); +} + +void +java::lang::Thread::resume (void) +{ + checkAccess (); + JvFail ("java::lang::Thread::resume unimplemented"); +} + +void +java::lang::Thread::setPriority (jint newPriority) +{ + checkAccess (); + if (newPriority < MIN_PRIORITY || newPriority > MAX_PRIORITY) + _Jv_Throw (new IllegalArgumentException); + + jint gmax = group->getMaxPriority(); + if (newPriority > gmax) + newPriority = gmax; + + priority = newPriority; + natThread *nt = (natThread *) data; + _Jv_ThreadSetPriority (nt->thread, priority); +} + +void +java::lang::Thread::sleep (jlong millis, jint nanos) +{ + if (millis < 0 || nanos < 0 || nanos > 999999) + _Jv_Throw (new IllegalArgumentException); + + Thread *current = currentThread (); + if (current->isInterrupted ()) + _Jv_Throw (new InterruptedException); + + // We use a condition variable to implement sleeping so that an + // interrupt can wake us up. + natThread *nt = (natThread *) current->data; + _Jv_MutexLock (&nt->interrupt_mutex); + _Jv_CondWait (&nt->interrupt_cond, &nt->interrupt_mutex, + millis, nanos); + _Jv_MutexUnlock (&nt->interrupt_mutex); + + if (current->isInterrupted ()) + _Jv_Throw (new InterruptedException); +} + +void +java::lang::Thread::finish_ (void) +{ + // Notify all threads waiting to join this thread. + _Jv_MonitorEnter (this); + alive_flag = false; + + // Note that we don't bother cleaning up the joiner list here. That + // is taken care of when each thread wakes up again. + natThread *nt = (natThread *) data; + for (natThread *t = nt->joiner; t != NULL; t = t->next) + { + _Jv_MutexLock (&t->interrupt_mutex); + _Jv_CondNotify (&t->interrupt_cond, &t->interrupt_mutex); + _Jv_MutexUnlock (&t->interrupt_mutex); + } + + _Jv_MonitorExit (this); +} + +void +java::lang::Thread::run__ (jobject obj) +{ + java::lang::Thread *thread = (java::lang::Thread *) obj; + thread->run_ (); +} + +void +java::lang::Thread::start (void) +{ + JvSynchronize sync (this); + + if (alive_flag) + _Jv_Throw (new IllegalThreadStateException); + + alive_flag = true; + natThread *nt = (natThread *) data; + _Jv_ThreadStart (this, nt->thread, (_Jv_ThreadStartFunc *) &run__); +} + +void +java::lang::Thread::stop (java::lang::Throwable *e) +{ + JvSynchronize sync (this); + checkAccess (); + if (! e) + _Jv_Throw (new NullPointerException); + natThread *nt = (natThread *) data; + _Jv_ThreadCancel (nt->thread, e); +} + +void +java::lang::Thread::suspend (void) +{ + checkAccess (); + JvFail ("java::lang::Thread::suspend unimplemented"); +} + +void +java::lang::Thread::yield (void) +{ + _Jv_ThreadYield (); +} diff --git a/libjava/java/lang/reflect/AccessibleObject.java b/libjava/java/lang/reflect/AccessibleObject.java new file mode 100644 index 00000000000..8c869e167b0 --- /dev/null +++ b/libjava/java/lang/reflect/AccessibleObject.java @@ -0,0 +1,53 @@ +// AccessibleObject.java - Base for reflection objects. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang.reflect; + +/** + * @author Tom Tromey + * @date December 12, 1998 + */ +/* Written using JDK 1.2 beta docs. + * Status: Believed complete and correct. + */ + +public class AccessibleObject +{ + protected AccessibleObject () + { + flag = false; + } + + boolean isAccessible () + { + return flag; + } + + static void setAccessible (AccessibleObject[] array, boolean flag) + { + checkPermission (); + for (int i = 0; i < array.length; ++i) + array[i].flag = flag; + } + + void setAccessible (boolean flag) + { + checkPermission (); + this.flag = flag; + } + + private static final void checkPermission () + { + SecurityManager sm = System.getSecurityManager(); + // FIXME: sm.checkPermission(ReflectPermission ("suppressAccessChecks")) + } + + private boolean flag; +} diff --git a/libjava/java/lang/reflect/Array.java b/libjava/java/lang/reflect/Array.java new file mode 100644 index 00000000000..398f80d5643 --- /dev/null +++ b/libjava/java/lang/reflect/Array.java @@ -0,0 +1,78 @@ +// FileDescriptor.java - Open file or device + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang.reflect; + +/** + * @author Per Bothner + * @date january 12, 1999 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3. + * Status: Believe complete and correct. + */ + +public final class Array +{ + Array () { } + + public static native Object newInstance(Class componentType, int length); + public static native Object newInstance(Class elementType, int[] dimensions); + public static native int getLength (Object array); + + public static native Object get (Object array, int index); + public static native char getChar (Object array, int index); + public static native byte getByte (Object array, int index); + public static native short getShort (Object array, int index); + public static native int getInt (Object array, int index); + public static native long getLong (Object array, int index); + public static native float getFloat (Object array, int index); + public static native double getDouble (Object array, int index); + public static native boolean getBoolean (Object array, int index); + + private static native Class getElementType (Object array, int index); + + private static native void set (Object array, int index, + Object value, Class elType); + + public static void set (Object array, int index, Object value) + { + Class elType = getElementType(array, index); + if (! elType.isPrimitive()) + set(array, index, value, elType); + else if (value instanceof Byte) + setByte(array, index, ((Byte) value).byteValue()); + else if (value instanceof Short) + setShort (array, index, ((Short) value).shortValue()); + else if (value instanceof Integer) + setInt(array, index, ((Integer) value).intValue()); + else if (value instanceof Long) + setLong(array, index, ((Long) value).longValue()); + else if (value instanceof Float) + setFloat(array, index, ((Float) value).floatValue()); + else if (value instanceof Double) + setDouble(array, index, ((Double) value).doubleValue()); + else if (value instanceof Character) + setChar(array, index, ((Character) value).charValue()); + else if (value instanceof Boolean) + setBoolean(array, index, ((Boolean) value).booleanValue()); + else + throw new IllegalArgumentException(); + } + + public static native void setByte (Object array, int index, byte value); + public static native void setShort (Object array, int index, short value); + public static native void setInt (Object array, int index, int value); + public static native void setLong (Object array, int index, long value); + public static native void setFloat (Object array, int index, float value); + public static native void setDouble (Object array, int index, double value); + public static native void setChar (Object array, int index, char value); + public static native void setBoolean(Object array, int index, boolean value); +} diff --git a/libjava/java/lang/reflect/Constructor.java b/libjava/java/lang/reflect/Constructor.java new file mode 100644 index 00000000000..466c1204bae --- /dev/null +++ b/libjava/java/lang/reflect/Constructor.java @@ -0,0 +1,106 @@ +// Constructor.java - Represents a constructor for a class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang.reflect; + +/** + * @author Tom Tromey + * @date December 12, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Incomplete: needs a private constructor, and + * newInstance() needs to be written. + */ + +public final class Constructor extends AccessibleObject implements Member +{ + public boolean equals (Object obj) + { + if (! (obj instanceof Constructor)) + return false; + Constructor c = (Constructor) obj; + return decl_class == c.decl_class && index == c.index; + } + + public Class getDeclaringClass () + { + return decl_class; + } + + public Class[] getExceptionTypes () + { + return (Class[]) exception_types.clone(); + } + + public int getModifiers () + { + return modifiers; + } + + public String getName () + { + return decl_class.getName(); + } + + public Class[] getParameterTypes () + { + return (Class[]) parameter_types.clone(); + } + + public int hashCode () + { + // FIXME. + return getName().hashCode(); + } + + // FIXME: this must be native. Should share implementation with + // Method.invoke. + public Object newInstance (Object[] args) + throws InstantiationException, IllegalAccessException, + IllegalArgumentException, InvocationTargetException + { + return null; + } + + public String toString () + { + StringBuffer b = new StringBuffer (); + b.append(Modifier.toString(modifiers)); + b.append(" "); + b.append(getName()); + b.append("("); + for (int i = 0; i < parameter_types.length; ++i) + { + b.append(parameter_types[i].toString()); + if (i < parameter_types.length - 1) + b.append(","); + } + b.append(")"); + return b.toString(); + } + + // Can't create these. FIXME. + private Constructor () + { + } + + // Declaring class. + private Class decl_class; + // Exception types. + private Class[] exception_types; + // Modifiers. + private int modifiers; + // Parameter types. + private Class[] parameter_types; + // Index of this method in declaring class' method table. + private int index; +} diff --git a/libjava/java/lang/reflect/Field.java b/libjava/java/lang/reflect/Field.java new file mode 100644 index 00000000000..7c7e690926a --- /dev/null +++ b/libjava/java/lang/reflect/Field.java @@ -0,0 +1,264 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang.reflect; + +/** + * @author Per Bothner + * @date September 1998; February 1999. + */ +/* Status: Mostly implemented. + * However, access checks are not implemented. See natField.cc for + * _Jv_CheckFieldAccessibility as well as the missing getCaller. + * Note that the idea is to have to compiler convert calls to + * setXXX(...) and getXXX(...) to setXXX(CALLER, ...) and getXXX(CALLER, ...), + * where CALLER is reference to the class that contains the calls to + * setXXX or getXXX. This is easy for the compiler, and replaces + * expensive stack and table searching with a constant. + */ + +public final class Field extends AccessibleObject implements Member +{ + private Class declaringClass; + + // This is filled in by getName. + private String name; + + // Offset in bytes from the start of declaringClass's fields array. + private int offset; + + public boolean equals (Object fld) + { + if (! (fld instanceof Field)) + return false; + Field f = (Field) fld; + return declaringClass == f.declaringClass && offset == f.offset; + } + + public Class getDeclaringClass () + { + return declaringClass; + } + + public native String getName (); + + public native Class getType (); + + public native int getModifiers (); + + public int hashCode() + { + return (declaringClass.hashCode() ^ offset); + } + + // The idea is that the compiler will magically translate + // fld.getShort(obj) to fld.getShort(THISCLASS, obj). + // This makes checking assessiblity more efficient, + // since we don't have to do any stack-walking. + + public boolean getBoolean (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return getBoolean(null, obj); + } + public char getChar (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return getChar(null, obj); + } + + public byte getByte (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return getByte(null, obj); + } + + public short getShort (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return getShort(null, obj); + } + + public int getInt (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return getInt(null, obj); + } + + public long getLong (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return getLong(null, obj); + } + + public float getFloat (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return getFloat(null, obj); + } + + public double getDouble (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return getDouble(null, obj); + } + + public Object get (Object obj) + throws IllegalArgumentException, IllegalAccessException + { + return get(null, obj); + } + + private native boolean getBoolean (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + private native char getChar (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + private native byte getByte (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + private native short getShort (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + private native int getInt (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + private native long getLong (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + private native float getFloat (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + private native double getDouble (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + public native Object get (Class caller, Object obj) + throws IllegalArgumentException, IllegalAccessException; + + public void setByte (Object obj, byte b) + throws IllegalArgumentException, IllegalAccessException + { + setByte(null, obj, b); + } + + public void setShort (Object obj, short s) + throws IllegalArgumentException, IllegalAccessException + { + setShort(null, obj, s); + } + + public void setInt (Object obj, int i) + throws IllegalArgumentException, IllegalAccessException + { + setInt(null, obj, i); + } + + public void setLong (Object obj, long l) + throws IllegalArgumentException, IllegalAccessException + { + setLong(null, obj, l); + } + + public void setFloat (Object obj, float f) + throws IllegalArgumentException, IllegalAccessException + { + setFloat(null, obj, f); + } + + public void setDouble (Object obj, double d) + throws IllegalArgumentException, IllegalAccessException + { + setDouble(null, obj, d); + } + + public void setChar (Object obj, char c) + throws IllegalArgumentException, IllegalAccessException + { + setChar(null, obj, c); + } + + public void setBoolean (Object obj, boolean b) + throws IllegalArgumentException, IllegalAccessException + { + setBoolean(null, obj, b); + } + + public native void setByte (Class caller, Object obj, byte b) + throws IllegalArgumentException, IllegalAccessException; + + public native void setShort (Class caller, Object obj, short s) + throws IllegalArgumentException, IllegalAccessException; + + public native void setInt (Class caller, Object obj, int i) + throws IllegalArgumentException, IllegalAccessException; + + public native void setLong (Class caller, Object obj, long l) + throws IllegalArgumentException, IllegalAccessException; + + public native void setFloat (Class caller, Object obj, float f) + throws IllegalArgumentException, IllegalAccessException; + + public native void setDouble (Class caller, Object obj, double d) + throws IllegalArgumentException, IllegalAccessException; + + public native void setChar (Class caller, Object obj, char c) + throws IllegalArgumentException, IllegalAccessException; + + public native void setBoolean (Class caller, Object obj, boolean b) + throws IllegalArgumentException, IllegalAccessException; + + private native void set (Class caller, Object obj, Object val, Class type) + throws IllegalArgumentException, IllegalAccessException; + + public void set (Object object, Object value) + throws IllegalArgumentException, IllegalAccessException + { + set(null, object, value); + } + + public void set (Class caller, Object object, Object value) + throws IllegalArgumentException, IllegalAccessException + { + Class type = getType(); + if (! type.isPrimitive()) + set(caller, object, value, type); + else if (value instanceof Byte) + setByte(caller, object, ((Byte) value).byteValue()); + else if (value instanceof Short) + setShort (caller, object, ((Short) value).shortValue()); + else if (value instanceof Integer) + setInt(caller, object, ((Integer) value).intValue()); + else if (value instanceof Long) + setLong(caller, object, ((Long) value).longValue()); + else if (value instanceof Float) + setFloat(caller, object, ((Float) value).floatValue()); + else if (value instanceof Double) + setDouble(caller, object, ((Double) value).doubleValue()); + else if (value instanceof Character) + setChar(caller, object, ((Character) value).charValue()); + else if (value instanceof Boolean) + setBoolean(caller, object, ((Boolean) value).booleanValue()); + else + throw new IllegalArgumentException(); + } + + public String toString () + { + StringBuffer sbuf = new StringBuffer (); + int mods = getModifiers(); + if (mods != 0) + Modifier.toString(mods, sbuf); + sbuf.append(getType()); + sbuf.append(' '); + sbuf.append(getDeclaringClass()); + sbuf.append('.'); + sbuf.append(getName()); + return sbuf.toString(); + } +} diff --git a/libjava/java/lang/reflect/InvocationTargetException.java b/libjava/java/lang/reflect/InvocationTargetException.java new file mode 100644 index 00000000000..eccd5f7daed --- /dev/null +++ b/libjava/java/lang/reflect/InvocationTargetException.java @@ -0,0 +1,73 @@ +// InvocationTargetException.java - Wrapper exception for reflection. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang.reflect; +import java.io.PrintStream; +import java.io.PrintWriter; + +/** + * @author Tom Tromey + * @date December 12, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Believed complete and correct. + */ + +public class InvocationTargetException extends Exception +{ + public Throwable getTargetException () + { + return target; + } + + protected InvocationTargetException () + { + super (); + target = null; + } + + public InvocationTargetException (Throwable exception) + { + super (); + target = exception; + } + + public InvocationTargetException (Throwable exception, String msg) + { + super (msg); + target = exception; + } + + // This is from JDK 1.2. + public void printStackTrace () + { + if (target != null) + target.printStackTrace(); + } + + // This is from JDK 1.2. + public void printStackTrace (PrintStream s) + { + if (target != null) + target.printStackTrace(s); + } + + // This is from JDK 1.2. + public void printStackTrace (PrintWriter wr) + { + if (target != null) + target.printStackTrace(wr); + } + + // The wrapped exception. The name is specified by the + // serialization spec. + private Throwable target; +} diff --git a/libjava/java/lang/reflect/Member.java b/libjava/java/lang/reflect/Member.java new file mode 100644 index 00000000000..a54f05f689e --- /dev/null +++ b/libjava/java/lang/reflect/Member.java @@ -0,0 +1,26 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang.reflect; + +/** + * @author Per Bothner + * @date September 27, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition. + * Status: Believed complete and correct. + */ + +public interface Member +{ + public static final int PUBLIC = 0; + public static final int DECLARED = 1; + public Class getDeclaringClass (); + public int getModifiers (); + public String getName(); +} diff --git a/libjava/java/lang/reflect/Method.java b/libjava/java/lang/reflect/Method.java new file mode 100644 index 00000000000..01e830876e5 --- /dev/null +++ b/libjava/java/lang/reflect/Method.java @@ -0,0 +1,123 @@ +// Method.java - Represent method of class or interface. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.lang.reflect; + +/** + * @author Tom Tromey + * @date December 12, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Incomplete: needs a private constructor, and + * invoke() needs to be finished. + */ + +public final class Method extends AccessibleObject implements Member +{ + public boolean equals (Object obj) + { + if (! (obj instanceof Method)) + return false; + Method m = (Method) obj; + return declaringClass == m.declaringClass && offset == m.offset; + } + + public Class getDeclaringClass () + { + return declaringClass; + } + + public Class[] getExceptionTypes () + { + return (Class[]) exception_types.clone(); + } + + public native int getModifiers (); + + public native String getName (); + + private native void getType (); + + public Class[] getParameterTypes () + { + if (parameter_types == null) + getType(); + return (Class[]) parameter_types.clone(); + } + + public Class getReturnType () + { + if (return_type == null) + getType(); + return return_type; + } + + public int hashCode () + { + // FIXME. + return name.hashCode() + declaringClass.getName().hashCode(); + } + + public native Object invoke (Object obj, Object[] args) + throws IllegalAccessException, IllegalArgumentException, + InvocationTargetException; + + public String toString () + { + StringBuffer b = new StringBuffer (); + b.append(Modifier.toString(getModifiers())); + b.append(" "); + b.append(return_type.toString()); + b.append(" "); + b.append(declaringClass.toString()); + b.append("."); + b.append(name); + b.append("("); + for (int i = 0; i < parameter_types.length; ++i) + { + b.append(parameter_types[i].toString()); + if (i < parameter_types.length - 1) + b.append(","); + } + b.append(")"); + if (exception_types.length > 0) + { + b.append(" throws "); + for (int i = 0; i < exception_types.length; ++i) + { + b.append(exception_types[i].toString()); + if (i < exception_types.length - 1) + b.append(","); + } + } + return b.toString(); + } + + private Method () + { + } + + // Declaring class. + private Class declaringClass; + + // Exception types. + private Class[] exception_types; + // Name cache. (Initially null.) + private String name; + // Parameter types. + private Class[] parameter_types; + // Return type. + private Class return_type; + + // Offset in bytes from the start of declaringClass's methods array. + private int offset; +} diff --git a/libjava/java/lang/reflect/Modifier.java b/libjava/java/lang/reflect/Modifier.java new file mode 100644 index 00000000000..f9df49e80ee --- /dev/null +++ b/libjava/java/lang/reflect/Modifier.java @@ -0,0 +1,130 @@ +// Modifier.java - Process modifier values. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/** + * @author Tom Tromey + * @date October 1, 1998 + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct to version 1.1 + */ + +package java.lang.reflect; + +public class Modifier +{ + public static final int PUBLIC = 0x001; + public static final int PRIVATE = 0x002; + public static final int PROTECTED = 0x004; + public static final int STATIC = 0x008; + public static final int FINAL = 0x010; + public static final int SYNCHRONIZED = 0x020; + public static final int VOLATILE = 0x040; + public static final int TRANSIENT = 0x080; + public static final int NATIVE = 0x100; + public static final int INTERFACE = 0x200; + public static final int ABSTRACT = 0x400; + + public static boolean isAbstract (int mod) + { + return (mod & ABSTRACT) != 0; + } + + public static boolean isFinal (int mod) + { + return (mod & FINAL) != 0; + } + + public static boolean isInterface (int mod) + { + return (mod & INTERFACE) != 0; + } + + public static boolean isNative (int mod) + { + return (mod & NATIVE) != 0; + } + + public static boolean isPrivate (int mod) + { + return (mod & PRIVATE) != 0; + } + + public static boolean isProtected (int mod) + { + return (mod & PROTECTED) != 0; + } + + public static boolean isPublic (int mod) + { + return (mod & PUBLIC) != 0; + } + + public static boolean isStatic (int mod) + { + return (mod & STATIC) != 0; + } + + public static boolean isSynchronized (int mod) + { + return (mod & SYNCHRONIZED) != 0; + } + + public static boolean isTransient (int mod) + { + return (mod & TRANSIENT) != 0; + } + + public static boolean isVolatile (int mod) + { + return (mod & VOLATILE) != 0; + } + + public static String toString (int mod) + { + StringBuffer r = new StringBuffer (); + toString(mod, r); + return r.toString(); + } + + static void toString (int mod, StringBuffer r) + { + if (isPublic (mod)) + r.append("public "); + if (isProtected (mod)) + r.append("protected "); + if (isPrivate (mod)) + r.append("private "); + if (isAbstract (mod)) + r.append("abstract "); + if (isStatic (mod)) + r.append("static "); + if (isFinal (mod)) + r.append("final "); + if (isTransient (mod)) + r.append("transient "); + if (isVolatile (mod)) + r.append("volatile "); + if (isNative (mod)) + r.append("native "); + if (isSynchronized (mod)) + r.append("synchronized "); + if (isInterface (mod)) + r.append("interface "); + + // Trim trailing space. + int l = r.length(); + if (l > 0) + r.setLength(l - 1); + } +} diff --git a/libjava/java/lang/reflect/natArray.cc b/libjava/java/lang/reflect/natArray.cc new file mode 100644 index 00000000000..3da8b5c01ce --- /dev/null +++ b/libjava/java/lang/reflect/natArray.cc @@ -0,0 +1,339 @@ +// natField.cc - Implementation of java.lang.reflect.Field native methods. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +jobject +java::lang::reflect::Array::newInstance (jclass componentType, jint length) +{ + if (componentType->isPrimitive()) + return _Jv_NewPrimArray (componentType, length); + else + return JvNewObjectArray (length, componentType, NULL); + +} + +jobject +java::lang::reflect::Array::newInstance (jclass componentType, jintArray dimensions) +{ + jint ndims = dimensions->length; + if (ndims == 0) + return componentType->newInstance (); + jint* dims = elements (dimensions); + if (ndims == 1) + return newInstance (componentType, dims[0]); + jclass arrayType = componentType; + for (int i = 0; i < ndims; i++) + arrayType = _Jv_FindArrayClass (arrayType); + return _Jv_NewMultiArray (arrayType, ndims, dims); + +} + +jint +java::lang::reflect::Array::getLength (jobject array) +{ + jclass arrayType = array->getClass(); + if (! arrayType->isArray ()) + JvThrow (new java::lang::IllegalArgumentException()); + return ((__JArray*) array)->length; +} + +jclass +java::lang::reflect::Array::getElementType (jobject array, jint index) +{ + jclass arrayType = array->getClass(); + if (! arrayType->isArray ()) + JvThrow (new java::lang::IllegalArgumentException()); + jint length = ((__JArray*) array)->length; + if ((_Jv_uint) index >= (_Jv_uint) length) + _Jv_ThrowBadArrayIndex(index); + return arrayType->getComponentType (); +} + +jboolean +java::lang::reflect::Array::getBoolean (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (boolean)) + return elements ((jbooleanArray) array) [index]; + JvThrow (new java::lang::IllegalArgumentException()); +} + +jchar +java::lang::reflect::Array::getChar (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (char)) + return elements ((jcharArray) array) [index]; + JvThrow (new java::lang::IllegalArgumentException()); +} + +jbyte +java::lang::reflect::Array::getByte (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (byte)) + return elements ((jbyteArray) array) [index]; + JvThrow (new java::lang::IllegalArgumentException()); +} + +jshort +java::lang::reflect::Array::getShort (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (short)) + return elements ((jshortArray) array) [index]; + if (elementType == JvPrimClass (byte)) + return elements ((jbyteArray) array) [index]; + JvThrow (new java::lang::IllegalArgumentException()); +} + +jint +java::lang::reflect::Array::getInt (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (int)) + return elements ((jintArray) array) [index]; + if (elementType == JvPrimClass (short)) + return elements ((jshortArray) array) [index]; + if (elementType == JvPrimClass (byte)) + return elements ((jbyteArray) array) [index]; + if (elementType == JvPrimClass (char)) + return elements ((jcharArray) array) [index]; + JvThrow (new java::lang::IllegalArgumentException()); +} + +jlong +java::lang::reflect::Array::getLong (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (long)) + return elements ((jlongArray) array) [index]; + if (elementType == JvPrimClass (int)) + return elements ((jintArray) array) [index]; + if (elementType == JvPrimClass (short)) + return elements ((jshortArray) array) [index]; + if (elementType == JvPrimClass (byte)) + return elements ((jbyteArray) array) [index]; + if (elementType == JvPrimClass (char)) + return elements ((jcharArray) array) [index]; + JvThrow (new java::lang::IllegalArgumentException()); +} + +jfloat +java::lang::reflect::Array::getFloat (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (float)) + return elements ((jfloatArray) array) [index]; + if (elementType == JvPrimClass (long)) + return elements ((jlongArray) array) [index]; + if (elementType == JvPrimClass (int)) + return elements ((jintArray) array) [index]; + if (elementType == JvPrimClass (short)) + return elements ((jshortArray) array) [index]; + if (elementType == JvPrimClass (byte)) + return elements ((jbyteArray) array) [index]; + if (elementType == JvPrimClass (char)) + return elements ((jcharArray) array) [index]; + JvThrow (new java::lang::IllegalArgumentException()); +} + +jdouble +java::lang::reflect::Array::getDouble (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (double)) + return elements ((jdoubleArray) array) [index]; + if (elementType == JvPrimClass (float)) + return elements ((jfloatArray) array) [index]; + if (elementType == JvPrimClass (long)) + return elements ((jlongArray) array) [index]; + if (elementType == JvPrimClass (int)) + return elements ((jintArray) array) [index]; + if (elementType == JvPrimClass (short)) + return elements ((jshortArray) array) [index]; + if (elementType == JvPrimClass (byte)) + return elements ((jbyteArray) array) [index]; + if (elementType == JvPrimClass (char)) + return elements ((jcharArray) array) [index]; + JvThrow (new java::lang::IllegalArgumentException()); +} + +jobject +java::lang::reflect::Array::get (jobject array, jint index) +{ + jclass elementType = getElementType (array, index); + if (! elementType->isPrimitive ()) + return elements ((jobjectArray) array) [index]; + if (elementType == JvPrimClass (double)) + return new java::lang::Double (elements ((jdoubleArray) array) [index]); + if (elementType == JvPrimClass (float)) + return new java::lang::Float (elements ((jfloatArray) array) [index]); + if (elementType == JvPrimClass (long)) + return new java::lang::Long (elements ((jlongArray) array) [index]); + if (elementType == JvPrimClass (int)) + return new java::lang::Integer (elements ((jintArray) array) [index]); + if (elementType == JvPrimClass (short)) + return new java::lang::Short (elements ((jshortArray) array) [index]); + if (elementType == JvPrimClass (byte)) + return new java::lang::Byte (elements ((jbyteArray) array) [index]); + if (elementType == JvPrimClass (char)) + return new java::lang::Character (elements ((jcharArray) array) [index]); + if (elementType == JvPrimClass (boolean)) + if (elements ((jbooleanArray) array) [index]) + return java::lang::Boolean::TRUE; + else + return java::lang::Boolean::FALSE; + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::setChar (jobject array, jint index, jchar value) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (char)) + elements ((jcharArray) array) [index] = value; + else if (elementType == JvPrimClass (int)) + elements ((jintArray) array) [index] = value; + else if (elementType == JvPrimClass (long)) + elements ((jlongArray) array) [index] = value; + else if (elementType == JvPrimClass (float)) + elements ((jfloatArray) array) [index] = value; + else if (elementType == JvPrimClass (double)) + elements ((jdoubleArray) array) [index] = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::setByte (jobject array, jint index, jbyte value) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (byte)) + elements ((jbyteArray) array) [index] = value; + else if (elementType == JvPrimClass (short)) + elements ((jshortArray) array) [index] = value; + else if (elementType == JvPrimClass (int)) + elements ((jintArray) array) [index] = value; + else if (elementType == JvPrimClass (long)) + elements ((jlongArray) array) [index] = value; + else if (elementType == JvPrimClass (float)) + elements ((jfloatArray) array) [index] = value; + else if (elementType == JvPrimClass (double)) + elements ((jdoubleArray) array) [index] = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::setShort (jobject array, jint index, jshort value) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (short)) + elements ((jshortArray) array) [index] = value; + else if (elementType == JvPrimClass (int)) + elements ((jintArray) array) [index] = value; + else if (elementType == JvPrimClass (long)) + elements ((jlongArray) array) [index] = value; + else if (elementType == JvPrimClass (float)) + elements ((jfloatArray) array) [index] = value; + else if (elementType == JvPrimClass (double)) + elements ((jdoubleArray) array) [index] = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::setInt (jobject array, jint index, jint value) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (int)) + elements ((jintArray) array) [index] = value; + else if (elementType == JvPrimClass (long)) + elements ((jlongArray) array) [index] = value; + else if (elementType == JvPrimClass (float)) + elements ((jfloatArray) array) [index] = value; + else if (elementType == JvPrimClass (double)) + elements ((jdoubleArray) array) [index] = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::setLong (jobject array, jint index, jlong value) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (long)) + elements ((jlongArray) array) [index] = value; + else if (elementType == JvPrimClass (float)) + elements ((jfloatArray) array) [index] = value; + else if (elementType == JvPrimClass (double)) + elements ((jdoubleArray) array) [index] = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::setFloat (jobject array, jint index, jfloat value) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (float)) + elements ((jfloatArray) array) [index] = value; + else if (elementType == JvPrimClass (double)) + elements ((jdoubleArray) array) [index] = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::setDouble (jobject array, jint index, jdouble value) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (double)) + elements ((jdoubleArray) array) [index] = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::setBoolean (jobject array, + jint index, jboolean value) +{ + jclass elementType = getElementType (array, index); + if (elementType == JvPrimClass (boolean)) + elements ((jbooleanArray) array) [index] = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Array::set (jobject array, jint index, + jobject value, jclass elType) +{ + if (! _Jv_IsInstanceOf (value, elType)) + JvThrow (new java::lang::IllegalArgumentException ()); + elements ((jobjectArray) array) [index] = value; +} diff --git a/libjava/java/lang/reflect/natField.cc b/libjava/java/lang/reflect/natField.cc new file mode 100644 index 00000000000..2449b42545c --- /dev/null +++ b/libjava/java/lang/reflect/natField.cc @@ -0,0 +1,435 @@ +// natField.cc - Implementation of java.lang.reflect.Field native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +jint +java::lang::reflect::Field::getModifiers () +{ + return _Jv_FromReflectedField (this)->getModifiers (); +} + +jstring +java::lang::reflect::Field::getName () +{ + if (name == NULL) + name = _Jv_NewStringUtf8Const (_Jv_FromReflectedField (this)->name); + return name; +} + +jclass +java::lang::reflect::Field::getType () +{ + jfieldID fld = _Jv_FromReflectedField (this); + if (! fld->isResolved()) + { + JvSynchronize sync (declaringClass); + if (! fld->isResolved()) + { + fld->type + = _Jv_FindClassFromSignature(((Utf8Const*) (fld->type))->data, + declaringClass->getClassLoader()); + fld->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG; + } + } + return fld->type; +} + +static void +_Jv_CheckFieldAccessibility (jfieldID /*fld*/, jclass /*caller*/) +{ +#if 0 + if (caller == NULL) + caller = getCaller(); +#endif +#if 0 + _Jv_ushort flags = fld->getModifiers(); + check accesss; +#endif +} + +static void* +getAddr (java::lang::reflect::Field* field, jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (field); + _Jv_ushort flags = fld->getModifiers(); + if (! (flags & java::lang::reflect::Modifier::PUBLIC) + && ! field->isAccessible ()) + _Jv_CheckFieldAccessibility (fld, caller); + if (flags & java::lang::reflect::Modifier::STATIC) + { + jclass fldClass = field->getDeclaringClass (); + JvInitClass(fldClass); + return fld->u.addr; + } + else + { + if (obj == NULL) + _Jv_Throw (new java::lang::NullPointerException ()); + if (! _Jv_IsInstanceOf (obj, field->getDeclaringClass())) + JvThrow (new java::lang::IllegalArgumentException ()); + return (void*) ((char*) obj + fld->getOffset ()); + } +} + +static jboolean +getBoolean (jclass cls, void* addr) +{ + if (cls == JvPrimClass (boolean)) + return * (jboolean *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jchar +getChar (jclass cls, void* addr) +{ + if (cls == JvPrimClass (char)) + return * (jchar *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jbyte +getByte (jclass cls, void* addr) +{ + if (cls == JvPrimClass (byte)) + return * (jbyte *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jshort +getShort (jclass cls, void* addr) +{ + if (cls == JvPrimClass (short)) + return * (jshort *) addr; + if (cls == JvPrimClass (byte)) + return * (jbyte *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jint +getInt (jclass cls, void* addr) +{ + if (cls == JvPrimClass (int)) + return * (jint *) addr; + if (cls == JvPrimClass (short)) + return * (jshort *) addr; + if (cls == JvPrimClass (char)) + return * (jchar *) addr; + if (cls == JvPrimClass (byte)) + return * (jbyte *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jlong +getLong (jclass cls, void* addr) +{ + if (cls == JvPrimClass (long)) + return * (jlong *) addr; + return ::getInt(cls, addr); +} + +static jfloat +getFloat (jclass cls, void* addr) +{ + if (cls == JvPrimClass (float)) + return * (jfloat *) addr; + if (cls == JvPrimClass (long)) + return * (jlong *) addr; + return ::getInt(cls, addr); +} + +static jdouble +getDouble (jclass cls, void* addr) +{ + if (cls == JvPrimClass (double)) + return * (jdouble *) addr; + if (cls == JvPrimClass (float)) + return * (jfloat *) addr; + if (cls == JvPrimClass (long)) + return * (jlong *) addr; + return ::getInt(cls, addr); +} + +jboolean +java::lang::reflect::Field::getBoolean (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getBoolean (fld->type, getAddr (this, caller, obj)); +} + +jchar +java::lang::reflect::Field::getChar (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getChar (fld->type, getAddr (this, caller, obj)); +} + +jbyte +java::lang::reflect::Field::getByte (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getByte (fld->type, getAddr (this, caller, obj)); +} + +jshort +java::lang::reflect::Field::getShort (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getShort (fld->type, getAddr (this, caller, obj)); +} + +jint +java::lang::reflect::Field::getInt (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getInt (fld->type, getAddr (this, caller, obj)); +} + +jlong +java::lang::reflect::Field::getLong (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getLong (fld->type, getAddr (this, caller, obj)); +} + +jfloat +java::lang::reflect::Field::getFloat (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getFloat (fld->type, getAddr (this, caller, obj)); +} + +jdouble +java::lang::reflect::Field::getDouble (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getDouble (fld->type, getAddr (this, caller, obj)); +} + +jobject +java::lang::reflect::Field::get (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + void* addr = getAddr (this, caller, obj); + if (! fld->type->isPrimitive ()) + return * (jobject*) addr; + if (fld->type == JvPrimClass (double)) + return new java::lang::Double (* (jdouble*) addr); + if (fld->type == JvPrimClass (float)) + return new java::lang::Float (* (jfloat*) addr); + if (fld->type == JvPrimClass (long)) + return new java::lang::Long (* (jlong*) addr); + if (fld->type == JvPrimClass (int)) + return new java::lang::Integer (* (jint*) addr); + if (fld->type == JvPrimClass (short)) + return new java::lang::Short (* (jshort*) addr); + if (fld->type == JvPrimClass (byte)) + return new java::lang::Byte (* (jbyte*) addr); + if (fld->type == JvPrimClass (char)) + return new java::lang::Character (* (jchar*) addr); + if (fld->type == JvPrimClass (boolean)) + if (* (jboolean*) addr) + return java::lang::Boolean::TRUE; + else + return java::lang::Boolean::FALSE; + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setBoolean (jclass type, void *addr, jboolean value) +{ + if (type == JvPrimClass (boolean)) + * (jboolean *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setChar (jclass type, void *addr, jchar value) +{ + if (type == JvPrimClass (char)) + * (jchar *) addr = value; + else if (type == JvPrimClass (int)) + * (jint *) addr = value; + else if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setByte (jclass type, void *addr, jbyte value) +{ + if (type == JvPrimClass (byte)) + * (jbyte *) addr = value; + else if (type == JvPrimClass (short)) + * (jshort *) addr = value; + else if (type == JvPrimClass (int)) + * (jint *) addr = value; + else if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setShort (jclass type, void *addr, jshort value) +{ + if (type == JvPrimClass (short)) + * (jshort *) addr = value; + else if (type == JvPrimClass (int)) + * (jint *) addr = value; + else if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setInt (jclass type, void *addr, jint value) +{ + if (type == JvPrimClass (int)) + * (jint *) addr = value; + else if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setLong (jclass type, void *addr, jlong value) +{ + if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setFloat (jclass type, void *addr, jfloat value) +{ + if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setDouble (jclass type, void *addr, jdouble value) +{ + if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Field::setBoolean (jclass caller, jobject obj, jboolean b) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setBoolean (fld->type, getAddr (this, caller, obj), b); +} + +void +java::lang::reflect::Field::setChar (jclass caller, jobject obj, jchar c) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setChar (fld->type, getAddr (this, caller, obj), c); +} + +void +java::lang::reflect::Field::setByte (jclass caller, jobject obj, jbyte b) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setByte (fld->type, getAddr (this, caller, obj), b); +} + +void +java::lang::reflect::Field::setShort (jclass caller, jobject obj, jshort s) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setShort (fld->type, getAddr (this, caller, obj), s); +} + +void +java::lang::reflect::Field::setInt (jclass caller, jobject obj, jint i) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setInt (fld->type, getAddr (this, caller, obj), i); +} + +void +java::lang::reflect::Field::setLong (jclass caller, jobject obj, jlong l) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setLong (fld->type, getAddr (this, caller, obj), l); +} +void +java::lang::reflect::Field::setFloat (jclass caller, jobject obj, jfloat f) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setFloat (fld->type, getAddr (this, caller, obj), f); +} + +void +java::lang::reflect::Field::setDouble (jclass caller, jobject obj, jdouble d) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setDouble (fld->type, getAddr (this, caller, obj), d); +} + +void +java::lang::reflect::Field::set (jclass caller, jobject object, jobject value, jclass type) +{ + if (! _Jv_IsInstanceOf (value, type)) + JvThrow (new java::lang::IllegalArgumentException ()); + void* addr = getAddr (this, caller, object); + * (jobject*) addr = value; +} diff --git a/libjava/java/lang/reflect/natMethod.cc b/libjava/java/lang/reflect/natMethod.cc new file mode 100644 index 00000000000..720bbc3d74e --- /dev/null +++ b/libjava/java/lang/reflect/natMethod.cc @@ -0,0 +1,386 @@ +// natMethod.cc - Native code for Method class. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +// This is about 90% done. Search for FIXME to see what remains. + +#include + +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define ClassClass _CL_Q34java4lang5Class +extern java::lang::Class ClassClass; + +#include + +#if 0 + +#include + +#define VoidClass _CL_Q34java4lang4Void +extern java::lang::Class VoidClass; +#define ByteClass _CL_Q34java4lang4Byte +extern java::lang::Class ByteClass; +#define ShortClass _CL_Q34java4lang5Short +extern java::lang::Class ShortClass; +#define CharacterClass _CL_Q34java4lang9Character +extern java::lang::Class CharacterClass; +#define IntegerClass _CL_Q34java4lang7Integer +extern java::lang::Class IntegerClass; +#define LongClass _CL_Q34java4lang4Long +extern java::lang::Class LongClass; +#define FloatClass _CL_Q34java4lang5Float +extern java::lang::Class FloatClass; +#define DoubleClass _CL_Q34java4lang6Double +extern java::lang::Class DoubleClass; + +struct cpair +{ + jclass prim; + jclass wrap; +}; + +// This is used to determine when a primitive widening conversion is +// allowed. +static cpair primitives[] = +{ +#define VOID 0 + { JvPrimClass (void), &VoidClass }, + { JvPrimClass (byte), &ByteClass }, +#define SHORT 2 + { JvPrimClass (short), &ShortClass }, +#define CHAR 3 + { JvPrimClass (char), &CharacterClass }, + { JvPrimClass (int), &IntegerClass }, + { JvPrimClass (long), &LongClass }, + { JvPrimClass (float), &FloatClass }, + { JvPrimClass (double), &DoubleClass }, + { NULL, NULL } +}; + +static jboolean +can_widen (jclass from, jclass to) +{ + int fromx = -1, tox = -1; + + for (int i = 0; primitives[i].prim; ++i) + { + if (primitives[i].wrap == from) + fromx = i; + if (primitives[i].prim == to) + tox = i; + } + + // Can't handle a miss. + if (fromx == -1 || tox == -1) + return false; + // Can't handle Void arguments. + if (fromx == VOID || tox == VOID) + return false; + // Special-case short/char conversions. + if ((fromx == SHORT && tox == CHAR) || (fromx == CHAR && tox == SHORT)) + return false; + + return fromx <= tox; +} + +static ffi_type * +get_ffi_type (jclass klass) +{ + // A special case. + if (klass == NULL) + return &ffi_type_pointer; + + ffi_type *r; + if (klass == JvPrimClass (byte)) + r = &ffi_type_sint8; + else if (klass == JvPrimClass (short)) + r = &ffi_type_sint16; + else if (klass == JvPrimClass (int)) + r = &ffi_type_sint32; + else if (klass == JvPrimClass (long)) + r = &ffi_type_sint64; + else if (klass == JvPrimClass (float)) + r = &ffi_type_float; + else if (klass == JvPrimClass (double)) + r = &ffi_type_double; + else if (klass == JvPrimClass (boolean)) + { + // FIXME. + r = &ffi_type_sint8; + } + else if (klass == JvPrimClass (char)) + r = &ffi_type_uint16; + else + { + JvAssert (! klass->isPrimitive()); + r = &ffi_type_pointer; + } + + return r; +} + +// FIXME: the body of this method should be a separate function so +// that Constructor can use it too. +jobject +java::lang::reflect::Method::invoke (jobject obj, + jobjectArray args) +{ + // FIXME: we need to be a friend of Class here. + _Jv_Method *meth = decl_class->methods[index]; + if (! java::lang::reflect::Modifier::isStatic(modifiers)) + { + jclass k = obj ? obj->getClass() : NULL; + if (! obj || ! decl_class->isAssignableFrom(k)) + JvThrow (new java::lang::NullPointerException); + // FIXME: access checks. + meth = _Jv_LookupMethod (k, meth->name, meth->signature); + } + + // FIXME: access checks. + + if (parameter_types->length != args->length) + JvThrow (new java::lang::IllegalArgumentException); + + ffi_type *rtype = get_ffi_type (return_type); + ffi_type **argtypes = (ffi_type **) alloca (parameter_types->length + * sizeof (ffi_type *)); + + jobject *paramelts = elements (parameter_types); + jobject *argelts = elements (args); + + int size = 0; + for (int i = 0; i < parameter_types->length; ++i) + { + jclass k = argelts[i] ? argelts[i]->getClass() : NULL; + argtypes[i] = get_ffi_type (k); + if (paramelts[i]->isPrimitive()) + { + if (! argelts[i] + || ! k->isPrimitive () + || ! can_widen (k, paramelts[i])) + JvThrow (new java::lang::IllegalArgumentException); + size += paramelts[i]->size(); + } + else + { + if (argelts[i] && ! paramelts[i]->isAssignableFrom (k)) + JvThrow (new java::lang::IllegalArgumentException); + size += sizeof (jobject); + } + } + + ffi_cif cif; + if (ffi_prep_cif (&cif, FFI_DEFAULT_ABI, parameter_types->length, + rtype, argtypes) != FFI_OK) + { + // FIXME: throw some kind of VirtualMachineError here. + } + + char *values = (char *) alloca (size); + char *p = values; + +#define COPY(Where, What, Type) \ + do { \ + Type val = (What); \ + memcpy ((Where), &val, sizeof (Type)); \ + Where += sizeof (Type); \ + } while (0) + + for (int i = 0; i < parameter_types->length; ++i) + { + java::lang::Number *num = (java::lang::Number *) paramelts[i]; + if (paramelts[i] == JvPrimClass (byte)) + COPY (p, num->byteValue(), jbyte); + else if (paramelts[i] == JvPrimClass (short)) + COPY (p, num->shortValue(), jshort); + else if (paramelts[i] == JvPrimClass (int)) + COPY (p, num->intValue(), jint); + else if (paramelts[i] == JvPrimClass (long)) + COPY (p, num->longValue(), jlong); + else if (paramelts[i] == JvPrimClass (float)) + COPY (p, num->floatValue(), jfloat); + else if (paramelts[i] == JvPrimClass (double)) + COPY (p, num->doubleValue(), jdouble); + else if (paramelts[i] == JvPrimClass (boolean)) + COPY (p, ((java::lang::Boolean *) argelts[i])->booleanValue(), jboolean); + else if (paramelts[i] == JvPrimClass (char)) + COPY (p, ((java::lang::Character *) argelts[i])->charValue(), jchar); + else + { + JvAssert (! paramelts[i]->isPrimitive()); + COPY (p, argelts[i], jobject); + } + } + + // FIXME: exception handling. + java::lang::Throwable *ex; + jdouble ret_value; // Largest possible value. Hopefully + // it is aligned! + ex = TRAMP_CALL (ffi_call (&cif, meth->ncode, &ret_value, (void *) values)); + + if (ex) + JvThrow (new InvocationTargetException (ex)); + + jobject r; +#define VAL(Wrapper, Type) (new Wrapper (* (Type *) &ret_value)) + if (return_type == JvPrimClass (byte)) + r = VAL (java::lang::Byte, jbyte); + else if (return_type == JvPrimClass (short)) + r = VAL (java::lang::Short, jshort); + else if (return_type == JvPrimClass (int)) + r = VAL (java::lang::Integer, jint); + else if (return_type == JvPrimClass (long)) + r = VAL (java::lang::Long, jlong); + else if (return_type == JvPrimClass (float)) + r = VAL (java::lang::Float, jfloat); + else if (return_type == JvPrimClass (double)) + r = VAL (java::lang::Double, jdouble); + else if (return_type == JvPrimClass (boolean)) + r = VAL (java::lang::Boolean, jboolean); + else if (return_type == JvPrimClass (char)) + r = VAL (java::lang::Character, jchar); + else if (return_type == JvPrimClass (void)) + r = NULL; + else + { + JvAssert (! return_type->isPrimitive()); + r = VAL (java::lang::Object, jobject); + } + + return r; +} + +#else /* 0 */ + +jobject +java::lang::reflect::Method::invoke (jobject, jobjectArray) +{ + JvFail ("not enabled yet"); +} + +#endif /* 0 */ + +jint +java::lang::reflect::Method::getModifiers () +{ + return _Jv_FromReflectedMethod (this)->accflags; +} + +jstring +java::lang::reflect::Method::getName () +{ + if (name == NULL) + name = _Jv_NewStringUtf8Const (_Jv_FromReflectedMethod (this)->name); + return name; +} + +/* Internal method to set return_type and parameter_types fields. */ + +void +java::lang::reflect::Method::getType () +{ + _Jv_Utf8Const* sig = _Jv_FromReflectedMethod (this)->signature; + java::lang::ClassLoader *loader = declaringClass->getClassLoader(); + char *ptr = sig->data; + int numArgs = 0; + /* First just count the number of parameters. */ + for (; ; ptr++) + { + switch (*ptr) + { + case 0: + case ')': + case 'V': + break; + case '[': + case '(': + continue; + case 'B': + case 'C': + case 'D': + case 'F': + case 'S': + case 'I': + case 'J': + case 'Z': + numArgs++; + continue; + case 'L': + numArgs++; + do + ptr++; + while (*ptr != ';' && ptr[1] != '\0'); + continue; + } + break; + } + + JArray *args = (JArray *) + JvNewObjectArray (numArgs, &ClassClass, NULL); + jclass* argPtr = elements (args); + for (ptr = sig->data; *ptr != '\0'; ptr++) + { + int num_arrays = 0; + jclass type; + for (; *ptr == '['; ptr++) + num_arrays++; + switch (*ptr) + { + default: + return; + case ')': + argPtr = &return_type; + continue; + case '(': + continue; + case 'V': + case 'B': + case 'C': + case 'D': + case 'F': + case 'S': + case 'I': + case 'J': + case 'Z': + type = _Jv_FindClassFromSignature(ptr, loader); + break; + case 'L': + type = _Jv_FindClassFromSignature(ptr, loader); + do + ptr++; + while (*ptr != ';' && ptr[1] != '\0'); + break; + } + while (--num_arrays >= 0) + type = _Jv_FindArrayClass (type); + *argPtr++ = type; + } + parameter_types = args; +} diff --git a/libjava/java/lang/s_atan.c b/libjava/java/lang/s_atan.c new file mode 100644 index 00000000000..b1410ecca55 --- /dev/null +++ b/libjava/java/lang/s_atan.c @@ -0,0 +1,181 @@ + +/* @(#)s_atan.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* +FUNCTION + <>, <>---arc tangent + +INDEX + atan +INDEX + atanf + +ANSI_SYNOPSIS + #include + double atan(double <[x]>); + float atanf(float <[x]>); + +TRAD_SYNOPSIS + #include + double atan(<[x]>); + double <[x]>; + + float atanf(<[x]>); + float <[x]>; + +DESCRIPTION + +<> computes the inverse tangent (arc tangent) of the input value. + +<> is identical to <>, save that it operates on <>. + +RETURNS +@ifinfo +<> returns a value in radians, in the range of -pi/2 to pi/2. +@end ifinfo +@tex +<> returns a value in radians, in the range of $-\pi/2$ to $\pi/2$. +@end tex + +PORTABILITY +<> is ANSI C. <> is an extension. + +*/ + +/* atan(x) + * Method + * 1. Reduce x to positive by atan(x) = -atan(-x). + * 2. According to the integer k=4t+0.25 chopped, t=x, the argument + * is further reduced to one of the following intervals and the + * arctangent of t is evaluated by the corresponding formula: + * + * [0,7/16] atan(x) = t-t^3*(a1+t^2*(a2+...(a10+t^2*a11)...) + * [7/16,11/16] atan(x) = atan(1/2) + atan( (t-0.5)/(1+t/2) ) + * [11/16.19/16] atan(x) = atan( 1 ) + atan( (t-1)/(1+t) ) + * [19/16,39/16] atan(x) = atan(3/2) + atan( (t-1.5)/(1+1.5t) ) + * [39/16,INF] atan(x) = atan(INF) + atan( -1/t ) + * + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double atanhi[] = { +#else +static double atanhi[] = { +#endif + 4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */ + 7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */ + 9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */ + 1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */ +}; + +#ifdef __STDC__ +static const double atanlo[] = { +#else +static double atanlo[] = { +#endif + 2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */ + 3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */ + 1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */ + 6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */ +}; + +#ifdef __STDC__ +static const double aT[] = { +#else +static double aT[] = { +#endif + 3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */ + -1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */ + 1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */ + -1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */ + 9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */ + -7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */ + 6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */ + -5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */ + 4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */ + -3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */ + 1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */ +}; + +#ifdef __STDC__ + static const double +#else + static double +#endif +one = 1.0, +huge = 1.0e300; + +#ifdef __STDC__ + double atan(double x) +#else + double atan(x) + double x; +#endif +{ + double w,s1,s2,z; + __int32_t ix,hx,id; + + GET_HIGH_WORD(hx,x); + ix = hx&0x7fffffff; + if(ix>=0x44100000) { /* if |x| >= 2^66 */ + __uint32_t low; + GET_LOW_WORD(low,x); + if(ix>0x7ff00000|| + (ix==0x7ff00000&&(low!=0))) + return x+x; /* NaN */ + if(hx>0) return atanhi[3]+atanlo[3]; + else return -atanhi[3]-atanlo[3]; + } if (ix < 0x3fdc0000) { /* |x| < 0.4375 */ + if (ix < 0x3e200000) { /* |x| < 2^-29 */ + if(huge+x>one) return x; /* raise inexact */ + } + id = -1; + } else { + x = fabs(x); + if (ix < 0x3ff30000) { /* |x| < 1.1875 */ + if (ix < 0x3fe60000) { /* 7/16 <=|x|<11/16 */ + id = 0; x = (2.0*x-one)/(2.0+x); + } else { /* 11/16<=|x|< 19/16 */ + id = 1; x = (x-one)/(x+one); + } + } else { + if (ix < 0x40038000) { /* |x| < 2.4375 */ + id = 2; x = (x-1.5)/(one+1.5*x); + } else { /* 2.4375 <= |x| < 2^66 */ + id = 3; x = -1.0/x; + } + }} + /* end of argument reduction */ + z = x*x; + w = z*z; + /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */ + s1 = z*(aT[0]+w*(aT[2]+w*(aT[4]+w*(aT[6]+w*(aT[8]+w*aT[10]))))); + s2 = w*(aT[1]+w*(aT[3]+w*(aT[5]+w*(aT[7]+w*aT[9])))); + if (id<0) return x - x*(s1+s2); + else { + z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x); + return (hx<0)? -z:z; + } +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_ceil.c b/libjava/java/lang/s_ceil.c new file mode 100644 index 00000000000..1476ef821be --- /dev/null +++ b/libjava/java/lang/s_ceil.c @@ -0,0 +1,80 @@ + +/* @(#)s_ceil.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * ceil(x) + * Return x rounded toward -inf to integral value + * Method: + * Bit twiddling. + * Exception: + * Inexact flag raised if x not equal to ceil(x). + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double huge = 1.0e300; +#else +static double huge = 1.0e300; +#endif + +#ifdef __STDC__ + double ceil(double x) +#else + double ceil(x) + double x; +#endif +{ + __int32_t i0,i1,j0; + __uint32_t i,j; + EXTRACT_WORDS(i0,i1,x); + j0 = ((i0>>20)&0x7ff)-0x3ff; + if(j0<20) { + if(j0<0) { /* raise inexact if x != 0 */ + if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */ + if(i0<0) {i0=0x80000000;i1=0;} + else if((i0|i1)!=0) { i0=0x3ff00000;i1=0;} + } + } else { + i = (0x000fffff)>>j0; + if(((i0&i)|i1)==0) return x; /* x is integral */ + if(huge+x>0.0) { /* raise inexact flag */ + if(i0>0) i0 += (0x00100000)>>j0; + i0 &= (~i); i1=0; + } + } + } else if (j0>51) { + if(j0==0x400) return x+x; /* inf or NaN */ + else return x; /* x is integral */ + } else { + i = ((__uint32_t)(0xffffffff))>>(j0-20); + if((i1&i)==0) return x; /* x is integral */ + if(huge+x>0.0) { /* raise inexact flag */ + if(i0>0) { + if(j0==20) i0+=1; + else { + j = i1 + (1<<(52-j0)); + if(j<(__uint32_t)i1) i0+=1; /* got a carry */ + i1 = j; + } + } + i1 &= (~i); + } + } + INSERT_WORDS(x,i0,i1); + return x; +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_copysign.c b/libjava/java/lang/s_copysign.c new file mode 100644 index 00000000000..bfc546db503 --- /dev/null +++ b/libjava/java/lang/s_copysign.c @@ -0,0 +1,82 @@ + +/* @(#)s_copysign.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION +<>, <>---sign of <[y]>, magnitude of <[x]> + +INDEX + copysign +INDEX + copysignf + +ANSI_SYNOPSIS + #include + double copysign (double <[x]>, double <[y]>); + float copysignf (float <[x]>, float <[y]>); + +TRAD_SYNOPSIS + #include + double copysign (<[x]>, <[y]>) + double <[x]>; + double <[y]>; + + float copysignf (<[x]>, <[y]>) + float <[x]>; + float <[y]>; + +DESCRIPTION +<> constructs a number with the magnitude (absolute value) +of its first argument, <[x]>, and the sign of its second argument, +<[y]>. + +<> does the same thing; the two functions differ only in +the type of their arguments and result. + +RETURNS +<> returns a <> with the magnitude of +<[x]> and the sign of <[y]>. +<> returns a <> with the magnitude of +<[x]> and the sign of <[y]>. + +PORTABILITY +<> is not required by either ANSI C or the System V Interface +Definition (Issue 2). + +*/ + +/* + * copysign(double x, double y) + * copysign(x,y) returns a value with the magnitude of x and + * with the sign bit of y. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double copysign(double x, double y) +#else + double copysign(x,y) + double x,y; +#endif +{ + __uint32_t hx,hy; + GET_HIGH_WORD(hx,x); + GET_HIGH_WORD(hy,y); + SET_HIGH_WORD(x,(hx&0x7fffffff)|(hy&0x80000000)); + return x; +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_cos.c b/libjava/java/lang/s_cos.c new file mode 100644 index 00000000000..c4712330137 --- /dev/null +++ b/libjava/java/lang/s_cos.c @@ -0,0 +1,82 @@ + +/* @(#)s_cos.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* cos(x) + * Return cosine function of x. + * + * kernel function: + * __kernel_sin ... sine function on [-pi/4,pi/4] + * __kernel_cos ... cosine function on [-pi/4,pi/4] + * __ieee754_rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double cos(double x) +#else + double cos(x) + double x; +#endif +{ + double y[2],z=0.0; + __int32_t n,ix; + + /* High word of x. */ + GET_HIGH_WORD(ix,x); + + /* |x| ~< pi/4 */ + ix &= 0x7fffffff; + if(ix <= 0x3fe921fb) return __kernel_cos(x,z); + + /* cos(Inf or NaN) is NaN */ + else if (ix>=0x7ff00000) return x-x; + + /* argument reduction needed */ + else { + n = __ieee754_rem_pio2(x,y); + switch(n&3) { + case 0: return __kernel_cos(y[0],y[1]); + case 1: return -__kernel_sin(y[0],y[1],1); + case 2: return -__kernel_cos(y[0],y[1]); + default: + return __kernel_sin(y[0],y[1],1); + } + } +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_fabs.c b/libjava/java/lang/s_fabs.c new file mode 100644 index 00000000000..95b871ca53a --- /dev/null +++ b/libjava/java/lang/s_fabs.c @@ -0,0 +1,73 @@ + +/* @(#)s_fabs.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION + <>, <>---absolute value (magnitude) +INDEX + fabs +INDEX + fabsf + +ANSI_SYNOPSIS + #include + double fabs(double <[x]>); + float fabsf(float <[x]>); + +TRAD_SYNOPSIS + #include + double fabs(<[x]>) + double <[x]>; + + float fabsf(<[x]>) + float <[x]>; + +DESCRIPTION +<> and <> calculate +@tex +$|x|$, +@end tex +the absolute value (magnitude) of the argument <[x]>, by direct +manipulation of the bit representation of <[x]>. + +RETURNS +The calculated value is returned. No errors are detected. + +PORTABILITY +<> is ANSI. +<> is an extension. + +*/ + +/* + * fabs(x) returns the absolute value of x. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double fabs(double x) +#else + double fabs(x) + double x; +#endif +{ + __uint32_t high; + GET_HIGH_WORD(high,x); + SET_HIGH_WORD(x,high&0x7fffffff); + return x; +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_floor.c b/libjava/java/lang/s_floor.c new file mode 100644 index 00000000000..86f73e0e136 --- /dev/null +++ b/libjava/java/lang/s_floor.c @@ -0,0 +1,134 @@ + +/* @(#)s_floor.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION +<>, <>, <>, <>---floor and ceiling +INDEX + floor +INDEX + floorf +INDEX + ceil +INDEX + ceilf + +ANSI_SYNOPSIS + #include + double floor(double <[x]>); + float floorf(float <[x]>); + double ceil(double <[x]>); + float ceilf(float <[x]>); + +TRAD_SYNOPSIS + #include + double floor(<[x]>) + double <[x]>; + float floorf(<[x]>) + float <[x]>; + double ceil(<[x]>) + double <[x]>; + float ceilf(<[x]>) + float <[x]>; + +DESCRIPTION +<> and <> find +@tex +$\lfloor x \rfloor$, +@end tex +the nearest integer less than or equal to <[x]>. +<> and <> find +@tex +$\lceil x\rceil$, +@end tex +the nearest integer greater than or equal to <[x]>. + +RETURNS +<> and <> return the integer result as a double. +<> and <> return the integer result as a float. + +PORTABILITY +<> and <> are ANSI. +<> and <> are extensions. + + +*/ + +/* + * floor(x) + * Return x rounded toward -inf to integral value + * Method: + * Bit twiddling. + * Exception: + * Inexact flag raised if x not equal to floor(x). + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double huge = 1.0e300; +#else +static double huge = 1.0e300; +#endif + +#ifdef __STDC__ + double floor(double x) +#else + double floor(x) + double x; +#endif +{ + __int32_t i0,i1,j0; + __uint32_t i,j; + EXTRACT_WORDS(i0,i1,x); + j0 = ((i0>>20)&0x7ff)-0x3ff; + if(j0<20) { + if(j0<0) { /* raise inexact if x != 0 */ + if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */ + if(i0>=0) {i0=i1=0;} + else if(((i0&0x7fffffff)|i1)!=0) + { i0=0xbff00000;i1=0;} + } + } else { + i = (0x000fffff)>>j0; + if(((i0&i)|i1)==0) return x; /* x is integral */ + if(huge+x>0.0) { /* raise inexact flag */ + if(i0<0) i0 += (0x00100000)>>j0; + i0 &= (~i); i1=0; + } + } + } else if (j0>51) { + if(j0==0x400) return x+x; /* inf or NaN */ + else return x; /* x is integral */ + } else { + i = ((__uint32_t)(0xffffffff))>>(j0-20); + if((i1&i)==0) return x; /* x is integral */ + if(huge+x>0.0) { /* raise inexact flag */ + if(i0<0) { + if(j0==20) i0+=1; + else { + j = i1+(1<<(52-j0)); + if(j<(__uint32_t)i1) i0 +=1 ; /* got a carry */ + i1=j; + } + } + i1 &= (~i); + } + } + INSERT_WORDS(x,i0,i1); + return x; +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_rint.c b/libjava/java/lang/s_rint.c new file mode 100644 index 00000000000..9936a49b801 --- /dev/null +++ b/libjava/java/lang/s_rint.c @@ -0,0 +1,87 @@ + +/* @(#)s_rint.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * rint(x) + * Return x rounded to integral value according to the prevailing + * rounding mode. + * Method: + * Using floating addition. + * Exception: + * Inexact flag raised if x not equal to rint(x). + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +TWO52[2]={ + 4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */ + -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */ +}; + +#ifdef __STDC__ + double rint(double x) +#else + double rint(x) + double x; +#endif +{ + __int32_t i0,j0,sx; + __uint32_t i,i1; + double t; + volatile double w; + EXTRACT_WORDS(i0,i1,x); + sx = (i0>>31)&1; + j0 = ((i0>>20)&0x7ff)-0x3ff; + if(j0<20) { + if(j0<0) { + if(((i0&0x7fffffff)|i1)==0) return x; + i1 |= (i0&0x0fffff); + i0 &= 0xfffe0000; + i0 |= ((i1|-i1)>>12)&0x80000; + SET_HIGH_WORD(x,i0); + w = TWO52[sx]+x; + t = w-TWO52[sx]; + GET_HIGH_WORD(i0,t); + SET_HIGH_WORD(t,(i0&0x7fffffff)|(sx<<31)); + return t; + } else { + i = (0x000fffff)>>j0; + if(((i0&i)|i1)==0) return x; /* x is integral */ + i>>=1; + if(((i0&i)|i1)!=0) { + if(j0==19) i1 = 0x40000000; else + i0 = (i0&(~i))|((0x20000)>>j0); + } + } + } else if (j0>51) { + if(j0==0x400) return x+x; /* inf or NaN */ + else return x; /* x is integral */ + } else { + i = ((__uint32_t)(0xffffffff))>>(j0-20); + if((i1&i)==0) return x; /* x is integral */ + i>>=1; + if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-20)); + } + INSERT_WORDS(x,i0,i1); + w = TWO52[sx]+x; + return w-TWO52[sx]; +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_scalbn.c b/libjava/java/lang/s_scalbn.c new file mode 100644 index 00000000000..b06834e913f --- /dev/null +++ b/libjava/java/lang/s_scalbn.c @@ -0,0 +1,104 @@ + +/* @(#)s_scalbn.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION +<>, <>---scale by integer +INDEX + scalbn +INDEX + scalbnf + +ANSI_SYNOPSIS + #include + double scalbn(double <[x]>, int <[y]>); + float scalbnf(float <[x]>, int <[y]>); + +TRAD_SYNOPSIS + #include + double scalbn(<[x]>,<[y]>) + double <[x]>; + int <[y]>; + float scalbnf(<[x]>,<[y]>) + float <[x]>; + int <[y]>; + +DESCRIPTION +<> and <> scale <[x]> by <[n]>, returning <[x]> times +2 to the power <[n]>. The result is computed by manipulating the +exponent, rather than by actually performing an exponentiation or +multiplication. + +RETURNS +<[x]> times 2 to the power <[n]>. + +PORTABILITY +Neither <> nor <> is required by ANSI C or by the System V +Interface Definition (Issue 2). + +*/ + +/* + * scalbn (double x, int n) + * scalbn(x,n) returns x* 2**n computed by exponent + * manipulation rather than by actually performing an + * exponentiation or a multiplication. + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */ +twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */ +huge = 1.0e+300, +tiny = 1.0e-300; + +#ifdef __STDC__ + double scalbn (double x, int n) +#else + double scalbn (x,n) + double x; int n; +#endif +{ + __int32_t k,hx,lx; + EXTRACT_WORDS(hx,lx,x); + k = (hx&0x7ff00000)>>20; /* extract exponent */ + if (k==0) { /* 0 or subnormal x */ + if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */ + x *= two54; + GET_HIGH_WORD(hx,x); + k = ((hx&0x7ff00000)>>20) - 54; + if (n< -50000) return tiny*x; /*underflow*/ + } + if (k==0x7ff) return x+x; /* NaN or Inf */ + k = k+n; + if (k > 0x7fe) return huge*copysign(huge,x); /* overflow */ + if (k > 0) /* normal result */ + {SET_HIGH_WORD(x,(hx&0x800fffff)|(k<<20)); return x;} + if (k <= -54) { + if (n > 50000) /* in case integer overflow in n+k */ + return huge*copysign(huge,x); /*overflow*/ + else return tiny*copysign(tiny,x); /*underflow*/ + } + k += 54; /* subnormal result */ + SET_HIGH_WORD(x,(hx&0x800fffff)|(k<<20)); + return x*twom54; +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_sin.c b/libjava/java/lang/s_sin.c new file mode 100644 index 00000000000..28259f378fe --- /dev/null +++ b/libjava/java/lang/s_sin.c @@ -0,0 +1,132 @@ + +/* @(#)s_sin.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION + <>, <>, <>, <>---sine or cosine +INDEX +sin +INDEX +sinf +INDEX +cos +INDEX +cosf +ANSI_SYNOPSIS + #include + double sin(double <[x]>); + float sinf(float <[x]>); + double cos(double <[x]>); + float cosf(float <[x]>); + +TRAD_SYNOPSIS + #include + double sin(<[x]>) + double <[x]>; + float sinf(<[x]>) + float <[x]>; + + double cos(<[x]>) + double <[x]>; + float cosf(<[x]>) + float <[x]>; + +DESCRIPTION + <> and <> compute (respectively) the sine and cosine + of the argument <[x]>. Angles are specified in radians. + + <> and <> are identical, save that they take and + return <> values. + + +RETURNS + The sine or cosine of <[x]> is returned. + +PORTABILITY + <> and <> are ANSI C. + <> and <> are extensions. + +QUICKREF + sin ansi pure + sinf - pure +*/ + +/* sin(x) + * Return sine function of x. + * + * kernel function: + * __kernel_sin ... sine function on [-pi/4,pi/4] + * __kernel_cos ... cose function on [-pi/4,pi/4] + * __ieee754_rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double sin(double x) +#else + double sin(x) + double x; +#endif +{ + double y[2],z=0.0; + __int32_t n,ix; + + /* High word of x. */ + GET_HIGH_WORD(ix,x); + + /* |x| ~< pi/4 */ + ix &= 0x7fffffff; + if(ix <= 0x3fe921fb) return __kernel_sin(x,z,0); + + /* sin(Inf or NaN) is NaN */ + else if (ix>=0x7ff00000) return x-x; + + /* argument reduction needed */ + else { + n = __ieee754_rem_pio2(x,y); + switch(n&3) { + case 0: return __kernel_sin(y[0],y[1],1); + case 1: return __kernel_cos(y[0],y[1]); + case 2: return -__kernel_sin(y[0],y[1],1); + default: + return -__kernel_cos(y[0],y[1]); + } + } +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/s_tan.c b/libjava/java/lang/s_tan.c new file mode 100644 index 00000000000..2959f416e83 --- /dev/null +++ b/libjava/java/lang/s_tan.c @@ -0,0 +1,114 @@ + +/* @(#)s_tan.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + + +/* + +FUNCTION + <>, <>---tangent + +INDEX +tan +INDEX +tanf + +ANSI_SYNOPSIS + #include + double tan(double <[x]>); + float tanf(float <[x]>); + +TRAD_SYNOPSIS + #include + double tan(<[x]>) + double <[x]>; + + float tanf(<[x]>) + float <[x]>; + + +DESCRIPTION +<> computes the tangent of the argument <[x]>. +Angles are specified in radians. + +<> is identical, save that it takes and returns <> values. + +RETURNS +The tangent of <[x]> is returned. + +PORTABILITY +<> is ANSI. <> is an extension. +*/ + +/* tan(x) + * Return tangent function of x. + * + * kernel function: + * __kernel_tan ... tangent function on [-pi/4,pi/4] + * __ieee754_rem_pio2 ... argument reduction routine + * + * Method. + * Let S,C and T denote the sin, cos and tan respectively on + * [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2 + * in [-pi/4 , +pi/4], and let n = k mod 4. + * We have + * + * n sin(x) cos(x) tan(x) + * ---------------------------------------------------------- + * 0 S C T + * 1 C -S -1/T + * 2 -S -C T + * 3 -C S -1/T + * ---------------------------------------------------------- + * + * Special cases: + * Let trig be any of sin, cos, or tan. + * trig(+-INF) is NaN, with signals; + * trig(NaN) is that NaN; + * + * Accuracy: + * TRIG(x) returns trig(x) nearly rounded + */ + +#include "fdlibm.h" + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double tan(double x) +#else + double tan(x) + double x; +#endif +{ + double y[2],z=0.0; + __int32_t n,ix; + + /* High word of x. */ + GET_HIGH_WORD(ix,x); + + /* |x| ~< pi/4 */ + ix &= 0x7fffffff; + if(ix <= 0x3fe921fb) return __kernel_tan(x,z,1); + + /* tan(Inf or NaN) is NaN */ + else if (ix>=0x7ff00000) return x-x; /* NaN */ + + /* argument reduction needed */ + else { + n = __ieee754_rem_pio2(x,y); + return __kernel_tan(y[0],y[1],1-((n&1)<<1)); /* 1 -- n even + -1 -- n odd */ + } +} + +#endif /* _DOUBLE_IS_32BITS */ diff --git a/libjava/java/lang/sf_rint.c b/libjava/java/lang/sf_rint.c new file mode 100644 index 00000000000..e4769e0dc60 --- /dev/null +++ b/libjava/java/lang/sf_rint.c @@ -0,0 +1,80 @@ +/* sf_rint.c -- float version of s_rint.c. + * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com. + */ + +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +#include "fdlibm.h" + +#ifdef __STDC__ +static const float +#else +static float +#endif +TWO23[2]={ + 8.3886080000e+06, /* 0x4b000000 */ + -8.3886080000e+06, /* 0xcb000000 */ +}; + +#ifdef __STDC__ + float rintf(float x) +#else + float rintf(x) + float x; +#endif +{ + __int32_t i0,j0,sx; + __uint32_t i,i1; + float w,t; + GET_FLOAT_WORD(i0,x); + sx = (i0>>31)&1; + j0 = ((i0>>23)&0xff)-0x7f; + if(j0<23) { + if(j0<0) { + if((i0&0x7fffffff)==0) return x; + i1 = (i0&0x07fffff); + i0 &= 0xfff00000; + i0 |= ((i1|-i1)>>9)&0x400000; + SET_FLOAT_WORD(x,i0); + w = TWO23[sx]+x; + t = w-TWO23[sx]; + GET_FLOAT_WORD(i0,t); + SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31)); + return t; + } else { + i = (0x007fffff)>>j0; + if((i0&i)==0) return x; /* x is integral */ + i>>=1; + if((i0&i)!=0) i0 = (i0&(~i))|((0x100000)>>j0); + } + } else { + if(j0==0x80) return x+x; /* inf or NaN */ + else return x; /* x is integral */ + } + SET_FLOAT_WORD(x,i0); + w = TWO23[sx]+x; + return w-TWO23[sx]; +} + +#ifdef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double rint(double x) +#else + double rint(x) + double x; +#endif +{ + return (double) rintf((float) x); +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/strtod.c b/libjava/java/lang/strtod.c new file mode 100644 index 00000000000..e0e8e74828b --- /dev/null +++ b/libjava/java/lang/strtod.c @@ -0,0 +1,720 @@ +/* +FUNCTION + <>, <>---string to double or float + +INDEX + strtod +INDEX + _strtod_r +INDEX + strtodf + +ANSI_SYNOPSIS + #include + double strtod(const char *<[str]>, char **<[tail]>); + float strtodf(const char *<[str]>, char **<[tail]>); + + double _strtod_r(void *<[reent]>, + const char *<[str]>, char **<[tail]>); + +TRAD_SYNOPSIS + #include + double strtod(<[str]>,<[tail]>) + char *<[str]>; + char **<[tail]>; + + float strtodf(<[str]>,<[tail]>) + char *<[str]>; + char **<[tail]>; + + double _strtod_r(<[reent]>,<[str]>,<[tail]>) + char *<[reent]>; + char *<[str]>; + char **<[tail]>; + +DESCRIPTION + The function <> parses the character string <[str]>, + producing a substring which can be converted to a double + value. The substring converted is the longest initial + subsequence of <[str]>, beginning with the first + non-whitespace character, that has the format: + .[+|-]<[digits]>[.][<[digits]>][(e|E)[+|-]<[digits]>] + The substring contains no characters if <[str]> is empty, consists + entirely of whitespace, or if the first non-whitespace + character is something other than <<+>>, <<->>, <<.>>, or a + digit. If the substring is empty, no conversion is done, and + the value of <[str]> is stored in <<*<[tail]>>>. Otherwise, + the substring is converted, and a pointer to the final string + (which will contain at least the terminating null character of + <[str]>) is stored in <<*<[tail]>>>. If you want no + assignment to <<*<[tail]>>>, pass a null pointer as <[tail]>. + <> is identical to <> except for its return type. + + This implementation returns the nearest machine number to the + input decimal string. Ties are broken by using the IEEE + round-even rule. + + The alternate function <<_strtod_r>> is a reentrant version. + The extra argument <[reent]> is a pointer to a reentrancy structure. + +RETURNS + <> returns the converted substring value, if any. If + no conversion could be performed, 0 is returned. If the + correct value is out of the range of representable values, + plus or minus <> is returned, and <> is + stored in errno. If the correct value would cause underflow, 0 + is returned and <> is stored in errno. + +Supporting OS subroutines required: <>, <>, <>, +<>, <>, <>, <>. +*/ + +/**************************************************************** + * + * The author of this software is David M. Gay. + * + * Copyright (c) 1991 by AT&T. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose without fee is hereby granted, provided that this entire notice + * is included in all copies of any software which is or includes a copy + * or modification of this software and in all copies of the supporting + * documentation for such software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY + * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. + * + ***************************************************************/ + +/* Please send bug reports to + David M. Gay + AT&T Bell Laboratories, Room 2C-463 + 600 Mountain Avenue + Murray Hill, NJ 07974-2070 + U.S.A. + dmg@research.att.com or research!dmg + */ + +#include +#include +#include +#include "mprec.h" + +double +_DEFUN (_strtod_r, (ptr, s00, se), + struct _Jv_reent *ptr _AND + _CONST char *s00 _AND + char **se) +{ + int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign, e1, esign, i, j, + k, nd, nd0, nf, nz, nz0, sign; + int digits = 0; /* Number of digits found in fraction part. */ + long e; + _CONST char *s, *s0, *s1; + double aadj, aadj1, adj; + long L; + unsigned long y, z; + union double_union rv, rv0; + + _Jv_Bigint *bb, *bb1, *bd, *bd0, *bs, *delta; + sign = nz0 = nz = 0; + rv.d = 0.; + for (s = s00;; s++) + switch (*s) + { + case '-': + sign = 1; + /* no break */ + case '+': + if (*++s) + goto break2; + /* no break */ + case 0: + s = s00; + goto ret; + case '\t': + case '\n': + case '\v': + case '\f': + case '\r': + case ' ': + continue; + default: + goto break2; + } +break2: + if (*s == '0') + { + digits++; + nz0 = 1; + while (*++s == '0') + digits++; + if (!*s) + goto ret; + } + s0 = s; + y = z = 0; + for (nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++) + { + digits++; + if (nd < 9) + y = 10 * y + c - '0'; + else if (nd < 16) + z = 10 * z + c - '0'; + } + nd0 = nd; + if (c == '.') + { + c = *++s; + if (!nd) + { + for (; c == '0'; c = *++s) + { + digits++; + nz++; + } + if (c > '0' && c <= '9') + { + digits++; + s0 = s; + nf += nz; + nz = 0; + goto have_dig; + } + goto dig_done; + } + for (; c >= '0' && c <= '9'; c = *++s) + { + digits++; + have_dig: + nz++; + if (c -= '0') + { + nf += nz; + for (i = 1; i < nz; i++) + if (nd++ < 9) + y *= 10; + else if (nd <= DBL_DIG + 1) + z *= 10; + if (nd++ < 9) + y = 10 * y + c; + else if (nd <= DBL_DIG + 1) + z = 10 * z + c; + nz = 0; + } + } + } +dig_done: + e = 0; + if (c == 'e' || c == 'E') + { + if (!nd && !nz && !nz0) + { + s = s00; + goto ret; + } + s00 = s; + esign = 0; + switch (c = *++s) + { + case '-': + esign = 1; + case '+': + c = *++s; + } + if (c >= '0' && c <= '9') + { + while (c == '0') + c = *++s; + if (c > '0' && c <= '9') + { + e = c - '0'; + s1 = s; + while ((c = *++s) >= '0' && c <= '9') + e = 10 * e + c - '0'; + if (s - s1 > 8) + /* Avoid confusion from exponents + * so large that e might overflow. + */ + e = 9999999L; + if (esign) + e = -e; + } + else + { + /* No exponent after an 'E' : that's an error. */ + ptr->_errno = EINVAL; + e = 0; + goto ret; + } + } + else + s = s00; + } + if (!nd) + { + if (!nz && !nz0) + s = s00; + goto ret; + } + e1 = e -= nf; + + /* Now we have nd0 digits, starting at s0, followed by a + * decimal point, followed by nd-nd0 digits. The number we're + * after is the integer represented by those digits times + * 10**e */ + + if (!nd0) + nd0 = nd; + k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1; + rv.d = y; + if (k > 9) + rv.d = tens[k - 9] * rv.d + z; + bd0 = 0; + if (nd <= DBL_DIG +#ifndef RND_PRODQUOT + && FLT_ROUNDS == 1 +#endif + ) + { + if (!e) + goto ret; + if (e > 0) + { + if (e <= Ten_pmax) + { +#ifdef VAX + goto vax_ovfl_check; +#else + /* rv.d = */ rounded_product (rv.d, tens[e]); + goto ret; +#endif + } + i = DBL_DIG - nd; + if (e <= Ten_pmax + i) + { + /* A fancier test would sometimes let us do + * this for larger i values. + */ + e -= i; + rv.d *= tens[i]; +#ifdef VAX + /* VAX exponent range is so narrow we must + * worry about overflow here... + */ + vax_ovfl_check: + word0 (rv) -= P * Exp_msk1; + /* rv.d = */ rounded_product (rv.d, tens[e]); + if ((word0 (rv) & Exp_mask) + > Exp_msk1 * (DBL_MAX_EXP + Bias - 1 - P)) + goto ovfl; + word0 (rv) += P * Exp_msk1; +#else + /* rv.d = */ rounded_product (rv.d, tens[e]); +#endif + goto ret; + } + } +#ifndef Inaccurate_Divide + else if (e >= -Ten_pmax) + { + /* rv.d = */ rounded_quotient (rv.d, tens[-e]); + goto ret; + } +#endif + } + e1 += nd - k; + + /* Get starting approximation = rv.d * 10**e1 */ + + if (e1 > 0) + { + if ((i = e1 & 15)) + rv.d *= tens[i]; + + if (e1 &= ~15) + { + if (e1 > DBL_MAX_10_EXP) + { + ovfl: + ptr->_errno = ERANGE; + + /* Force result to IEEE infinity. */ + word0 (rv) = Exp_mask; + word1 (rv) = 0; + + if (bd0) + goto retfree; + goto ret; + } + if (e1 >>= 4) + { + for (j = 0; e1 > 1; j++, e1 >>= 1) + if (e1 & 1) + rv.d *= bigtens[j]; + /* The last multiplication could overflow. */ + word0 (rv) -= P * Exp_msk1; + rv.d *= bigtens[j]; + if ((z = word0 (rv) & Exp_mask) + > Exp_msk1 * (DBL_MAX_EXP + Bias - P)) + goto ovfl; + if (z > Exp_msk1 * (DBL_MAX_EXP + Bias - 1 - P)) + { + /* set to largest number */ + /* (Can't trust DBL_MAX) */ + word0 (rv) = Big0; +#ifndef _DOUBLE_IS_32BITS + word1 (rv) = Big1; +#endif + } + else + word0 (rv) += P * Exp_msk1; + } + + } + } + else if (e1 < 0) + { + e1 = -e1; + if ((i = e1 & 15)) + rv.d /= tens[i]; + if (e1 &= ~15) + { + e1 >>= 4; + if (e1 >= 1 << n_bigtens) + goto undfl; + for (j = 0; e1 > 1; j++, e1 >>= 1) + if (e1 & 1) + rv.d *= tinytens[j]; + /* The last multiplication could underflow. */ + rv0.d = rv.d; + rv.d *= tinytens[j]; + if (!rv.d) + { + rv.d = 2. * rv0.d; + rv.d *= tinytens[j]; + if (!rv.d) + { + undfl: + rv.d = 0.; + ptr->_errno = ERANGE; + if (bd0) + goto retfree; + goto ret; + } +#ifndef _DOUBLE_IS_32BITS + word0 (rv) = Tiny0; + word1 (rv) = Tiny1; +#else + word0 (rv) = Tiny1; +#endif + /* The refinement below will clean + * this approximation up. + */ + } + } + } + + /* Now the hard part -- adjusting rv to the correct value.*/ + + /* Put digits into bd: true value = bd * 10^e */ + + bd0 = s2b (ptr, s0, nd0, nd, y); + + for (;;) + { + bd = Balloc (ptr, bd0->_k); + Bcopy (bd, bd0); + bb = d2b (ptr, rv.d, &bbe, &bbbits); /* rv.d = bb * 2^bbe */ + bs = i2b (ptr, 1); + + if (e >= 0) + { + bb2 = bb5 = 0; + bd2 = bd5 = e; + } + else + { + bb2 = bb5 = -e; + bd2 = bd5 = 0; + } + if (bbe >= 0) + bb2 += bbe; + else + bd2 -= bbe; + bs2 = bb2; +#ifdef Sudden_Underflow +#ifdef IBM + j = 1 + 4 * P - 3 - bbbits + ((bbe + bbbits - 1) & 3); +#else + j = P + 1 - bbbits; +#endif +#else + i = bbe + bbbits - 1; /* logb(rv.d) */ + if (i < Emin) /* denormal */ + j = bbe + (P - Emin); + else + j = P + 1 - bbbits; +#endif + bb2 += j; + bd2 += j; + i = bb2 < bd2 ? bb2 : bd2; + if (i > bs2) + i = bs2; + if (i > 0) + { + bb2 -= i; + bd2 -= i; + bs2 -= i; + } + if (bb5 > 0) + { + bs = pow5mult (ptr, bs, bb5); + bb1 = mult (ptr, bs, bb); + Bfree (ptr, bb); + bb = bb1; + } + if (bb2 > 0) + bb = lshift (ptr, bb, bb2); + if (bd5 > 0) + bd = pow5mult (ptr, bd, bd5); + if (bd2 > 0) + bd = lshift (ptr, bd, bd2); + if (bs2 > 0) + bs = lshift (ptr, bs, bs2); + delta = diff (ptr, bb, bd); + dsign = delta->_sign; + delta->_sign = 0; + i = cmp (delta, bs); + if (i < 0) + { + /* Error is less than half an ulp -- check for + * special case of mantissa a power of two. + */ + if (dsign || word1 (rv) || word0 (rv) & Bndry_mask) + break; + delta = lshift (ptr, delta, Log2P); + if (cmp (delta, bs) > 0) + goto drop_down; + break; + } + if (i == 0) + { + /* exactly half-way between */ + if (dsign) + { + if ((word0 (rv) & Bndry_mask1) == Bndry_mask1 + && word1 (rv) == 0xffffffff) + { + /*boundary case -- increment exponent*/ + word0 (rv) = (word0 (rv) & Exp_mask) + + Exp_msk1 +#ifdef IBM + | Exp_msk1 >> 4 +#endif + ; +#ifndef _DOUBLE_IS_32BITS + word1 (rv) = 0; +#endif + break; + } + } + else if (!(word0 (rv) & Bndry_mask) && !word1 (rv)) + { + drop_down: + /* boundary case -- decrement exponent */ +#ifdef Sudden_Underflow + L = word0 (rv) & Exp_mask; +#ifdef IBM + if (L < Exp_msk1) +#else + if (L <= Exp_msk1) +#endif + goto undfl; + L -= Exp_msk1; +#else + L = (word0 (rv) & Exp_mask) - Exp_msk1; +#endif + word0 (rv) = L | Bndry_mask1; +#ifndef _DOUBLE_IS_32BITS + word1 (rv) = 0xffffffff; +#endif +#ifdef IBM + goto cont; +#else + break; +#endif + } +#ifndef ROUND_BIASED + if (!(word1 (rv) & LSB)) + break; +#endif + if (dsign) + rv.d += ulp (rv.d); +#ifndef ROUND_BIASED + else + { + rv.d -= ulp (rv.d); +#ifndef Sudden_Underflow + if (!rv.d) + goto undfl; +#endif + } +#endif + break; + } + if ((aadj = ratio (delta, bs)) <= 2.) + { + if (dsign) + aadj = aadj1 = 1.; + else if (word1 (rv) || word0 (rv) & Bndry_mask) + { +#ifndef Sudden_Underflow + if (word1 (rv) == Tiny1 && !word0 (rv)) + goto undfl; +#endif + aadj = 1.; + aadj1 = -1.; + } + else + { + /* special case -- power of FLT_RADIX to be */ + /* rounded down... */ + + if (aadj < 2. / FLT_RADIX) + aadj = 1. / FLT_RADIX; + else + aadj *= 0.5; + aadj1 = -aadj; + } + } + else + { + aadj *= 0.5; + aadj1 = dsign ? aadj : -aadj; +#ifdef Check_FLT_ROUNDS + switch (FLT_ROUNDS) + { + case 2: /* towards +infinity */ + aadj1 -= 0.5; + break; + case 0: /* towards 0 */ + case 3: /* towards -infinity */ + aadj1 += 0.5; + } +#else + if (FLT_ROUNDS == 0) + aadj1 += 0.5; +#endif + } + y = word0 (rv) & Exp_mask; + + /* Check for overflow */ + + if (y == Exp_msk1 * (DBL_MAX_EXP + Bias - 1)) + { + rv0.d = rv.d; + word0 (rv) -= P * Exp_msk1; + adj = aadj1 * ulp (rv.d); + rv.d += adj; + if ((word0 (rv) & Exp_mask) >= + Exp_msk1 * (DBL_MAX_EXP + Bias - P)) + { + if (word0 (rv0) == Big0 && word1 (rv0) == Big1) + goto ovfl; +#ifdef _DOUBLE_IS_32BITS + word0 (rv) = Big1; +#else + word0 (rv) = Big0; + word1 (rv) = Big1; +#endif + goto cont; + } + else + word0 (rv) += P * Exp_msk1; + } + else + { +#ifdef Sudden_Underflow + if ((word0 (rv) & Exp_mask) <= P * Exp_msk1) + { + rv0.d = rv.d; + word0 (rv) += P * Exp_msk1; + adj = aadj1 * ulp (rv.d); + rv.d += adj; +#ifdef IBM + if ((word0 (rv) & Exp_mask) < P * Exp_msk1) +#else + if ((word0 (rv) & Exp_mask) <= P * Exp_msk1) +#endif + { + if (word0 (rv0) == Tiny0 + && word1 (rv0) == Tiny1) + goto undfl; + word0 (rv) = Tiny0; + word1 (rv) = Tiny1; + goto cont; + } + else + word0 (rv) -= P * Exp_msk1; + } + else + { + adj = aadj1 * ulp (rv.d); + rv.d += adj; + } +#else + /* Compute adj so that the IEEE rounding rules will + * correctly round rv.d + adj in some half-way cases. + * If rv.d * ulp(rv.d) is denormalized (i.e., + * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid + * trouble from bits lost to denormalization; + * example: 1.2e-307 . + */ + if (y <= (P - 1) * Exp_msk1 && aadj >= 1.) + { + aadj1 = (double) (int) (aadj + 0.5); + if (!dsign) + aadj1 = -aadj1; + } + adj = aadj1 * ulp (rv.d); + rv.d += adj; +#endif + } + z = word0 (rv) & Exp_mask; + if (y == z) + { + /* Can we stop now? */ + L = aadj; + aadj -= L; + /* The tolerances below are conservative. */ + if (dsign || word1 (rv) || word0 (rv) & Bndry_mask) + { + if (aadj < .4999999 || aadj > .5000001) + break; + } + else if (aadj < .4999999 / FLT_RADIX) + break; + } + cont: + Bfree (ptr, bb); + Bfree (ptr, bd); + Bfree (ptr, bs); + Bfree (ptr, delta); + } +retfree: + Bfree (ptr, bb); + Bfree (ptr, bd); + Bfree (ptr, bs); + Bfree (ptr, bd0); + Bfree (ptr, delta); +ret: + if (se) + *se = (char *) s; + if (digits == 0) + ptr->_errno = EINVAL; + return sign ? -rv.d : rv.d; +} + diff --git a/libjava/java/lang/w_acos.c b/libjava/java/lang/w_acos.c new file mode 100644 index 00000000000..c9ca99c4041 --- /dev/null +++ b/libjava/java/lang/w_acos.c @@ -0,0 +1,118 @@ + +/* @(#)w_acos.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION + <>, <>---arc cosine + +INDEX + acos +INDEX + acosf + +ANSI_SYNOPSIS + #include + double acos(double <[x]>); + float acosf(float <[x]>); + +TRAD_SYNOPSIS + #include + double acos(<[x]>) + double <[x]>; + + float acosf(<[x]>) + float <[x]>; + + + +DESCRIPTION + + <> computes the inverse cosine (arc cosine) of the input value. + Arguments to <> must be in the range @minus{}1 to 1. + + <> is identical to <>, except that it performs + its calculations on <>. + +RETURNS + @ifinfo + <> and <> return values in radians, in the range of 0 to pi. + @end ifinfo + @tex + <> and <> return values in radians, in the range of <<0>> to $\pi$. + @end tex + + If <[x]> is not between @minus{}1 and 1, the returned value is NaN + (not a number) the global variable <> is set to <>, and a + <> message is sent as standard error output. + + You can modify error handling for these functions using <>. + + +QUICKREF ANSI SVID POSIX RENTRANT + acos y,y,y,m + acosf n,n,n,m + +MATHREF + acos, [-1,1], acos(arg),,, + acos, NAN, arg,DOMAIN,EDOM + +MATHREF + acosf, [-1,1], acosf(arg),,, + acosf, NAN, argf,DOMAIN,EDOM + +*/ + +/* + * wrap_acos(x) + */ + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double acos(double x) /* wrapper acos */ +#else + double acos(x) /* wrapper acos */ + double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_acos(x); +#else + double z; + struct exception exc; + z = __ieee754_acos(x); + if(_LIB_VERSION == _IEEE_ || isnan(x)) return z; + if(fabs(x)>1.0) { + /* acos(|x|>1) */ + exc.type = DOMAIN; + exc.name = "acos"; + exc.err = 0; + exc.arg1 = exc.arg2 = x; + exc.retval = 0.0; + if (_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else + return z; +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/w_asin.c b/libjava/java/lang/w_asin.c new file mode 100644 index 00000000000..f6cb271d392 --- /dev/null +++ b/libjava/java/lang/w_asin.c @@ -0,0 +1,121 @@ + +/* @(#)w_asin.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* +FUNCTION + <>, <>---arc sine + +INDEX + asin +INDEX + asinf + +ANSI_SYNOPSIS + #include + double asin(double <[x]>); + float asinf(float <[x]>); + +TRAD_SYNOPSIS + #include + double asin(<[x]>) + double <[x]>; + + float asinf(<[x]>) + float <[x]>; + + +DESCRIPTION + +<> computes the inverse sine (arc sine) of the argument <[x]>. +Arguments to <> must be in the range @minus{}1 to 1. + +<> is identical to <>, other than taking and +returning floats. + +You can modify error handling for these routines using <>. + +RETURNS +@ifinfo +<> returns values in radians, in the range of -pi/2 to pi/2. +@end ifinfo +@tex +<> returns values in radians, in the range of $-\pi/2$ to $\pi/2$. +@end tex + +If <[x]> is not in the range @minus{}1 to 1, <> and <> +return NaN (not a number), set the global variable <> to +<>, and issue a <> message. + +You can change this error treatment using <>. + +QUICKREF ANSI SVID POSIX RENTRANT + asin y,y,y,m + asinf n,n,n,m + +MATHREF + asin, -1<=arg<=1, asin(arg),,, + asin, NAN, arg,EDOM, DOMAIN + +MATHREF + asinf, -1<=arg<=1, asin(arg),,, + asinf, NAN, arg,EDOM, DOMAIN + + +*/ + +/* + * wrapper asin(x) + */ + + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double asin(double x) /* wrapper asin */ +#else + double asin(x) /* wrapper asin */ + double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_asin(x); +#else + double z; + struct exception exc; + z = __ieee754_asin(x); + if(_LIB_VERSION == _IEEE_ || isnan(x)) return z; + if(fabs(x)>1.0) { + /* asin(|x|>1) */ + exc.type = DOMAIN; + exc.name = "asin"; + exc.err = 0; + exc.arg1 = exc.arg2 = x; + exc.retval = 0.0; + if(_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else + return z; +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/w_atan2.c b/libjava/java/lang/w_atan2.c new file mode 100644 index 00000000000..91742c72b91 --- /dev/null +++ b/libjava/java/lang/w_atan2.c @@ -0,0 +1,117 @@ + +/* @(#)w_atan2.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* +FUNCTION + <>, <>---arc tangent of y/x + +INDEX + atan2 +INDEX + atan2f + +ANSI_SYNOPSIS + #include + double atan2(double <[y]>,double <[x]>); + float atan2f(float <[y]>,float <[x]>); + +TRAD_SYNOPSIS + #include + double atan2(<[y]>,<[x]>); + double <[y]>; + double <[x]>; + + float atan2f(<[y]>,<[x]>); + float <[y]>; + float <[x]>; + +DESCRIPTION + +<> computes the inverse tangent (arc tangent) of <[y]>/<[x]>. +<> produces the correct result even for angles near +@ifinfo +pi/2 or -pi/2 +@end ifinfo +@tex +$\pi/2$ or $-\pi/2$ +@end tex +(that is, when <[x]> is near 0). + +<> is identical to <>, save that it takes and returns +<>. + +RETURNS +<> and <> return a value in radians, in the range of +@ifinfo +-pi to pi. +@end ifinfo +@tex +$-\pi$ to $\pi$. +@end tex + +If both <[x]> and <[y]> are 0.0, <> causes a <> error. + +You can modify error handling for these functions using <>. + +PORTABILITY +<> is ANSI C. <> is an extension. + + +*/ + +/* + * wrapper atan2(y,x) + */ + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double atan2(double y, double x) /* wrapper atan2 */ +#else + double atan2(y,x) /* wrapper atan2 */ + double y,x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_atan2(y,x); +#else + double z; + struct exception exc; + z = __ieee754_atan2(y,x); + if(_LIB_VERSION == _IEEE_||isnan(x)||isnan(y)) return z; + if(x==0.0&&y==0.0) { + /* atan2(+-0,+-0) */ + exc.arg1 = y; + exc.arg2 = x; + exc.type = DOMAIN; + exc.name = "atan2"; + exc.err = 0; + exc.retval = 0.0; + if(_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else + return z; +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/w_exp.c b/libjava/java/lang/w_exp.c new file mode 100644 index 00000000000..ae792a84642 --- /dev/null +++ b/libjava/java/lang/w_exp.c @@ -0,0 +1,136 @@ + +/* @(#)w_exp.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION + <>, <>---exponential +INDEX + exp +INDEX + expf + +ANSI_SYNOPSIS + #include + double exp(double <[x]>); + float expf(float <[x]>); + +TRAD_SYNOPSIS + #include + double exp(<[x]>); + double <[x]>; + + float expf(<[x]>); + float <[x]>; + +DESCRIPTION + <> and <> calculate the exponential of <[x]>, that is, + @ifinfo + e raised to the power <[x]> (where e + @end ifinfo + @tex + $e^x$ (where $e$ + @end tex + is the base of the natural system of logarithms, approximately 2.71828). + + You can use the (non-ANSI) function <> to specify + error handling for these functions. + +RETURNS + On success, <> and <> return the calculated value. + If the result underflows, the returned value is <<0>>. If the + result overflows, the returned value is <>. In + either case, <> is set to <>. + +PORTABILITY + <> is ANSI C. <> is an extension. + +*/ + +/* + * wrapper exp(x) + */ + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ +static const double +#else +static double +#endif +o_threshold= 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */ +u_threshold= -7.45133219101941108420e+02; /* 0xc0874910, 0xD52D3051 */ + +#ifdef __STDC__ + double exp(double x) /* wrapper exp */ +#else + double exp(x) /* wrapper exp */ + double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_exp(x); +#else + double z; + struct exception exc; + z = __ieee754_exp(x); + if(_LIB_VERSION == _IEEE_) return z; + if(finite(x)) { + if(x>o_threshold) { + /* exp(finite) overflow */ +#ifndef HUGE_VAL +#define HUGE_VAL inf + double inf = 0.0; + + SET_HIGH_WORD(inf,0x7ff00000); /* set inf to infinite */ +#endif + exc.type = OVERFLOW; + exc.name = "exp"; + exc.err = 0; + exc.arg1 = exc.arg2 = x; + if (_LIB_VERSION == _SVID_) + exc.retval = HUGE; + else + exc.retval = HUGE_VAL; + if (_LIB_VERSION == _POSIX_) + errno = ERANGE; + else if (!matherr(&exc)) { + errno = ERANGE; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else if(x>, <>---floating-point remainder (modulo) + +INDEX +fmod +INDEX +fmodf + +ANSI_SYNOPSIS +#include +double fmod(double <[x]>, double <[y]>) +float fmodf(float <[x]>, float <[y]>) + +TRAD_SYNOPSIS +#include +double fmod(<[x]>, <[y]>) +double (<[x]>, <[y]>); + +float fmodf(<[x]>, <[y]>) +float (<[x]>, <[y]>); + +DESCRIPTION +The <> and <> functions compute the floating-point +remainder of <[x]>/<[y]> (<[x]> modulo <[y]>). + +RETURNS +The <> function returns the value +@ifinfo +<[x]>-<[i]>*<[y]>, +@end ifinfo +@tex +$x-i\times y$, +@end tex +for the largest integer <[i]> such that, if <[y]> is nonzero, the +result has the same sign as <[x]> and magnitude less than the +magnitude of <[y]>. + +<,0)>> returns NaN, and sets <> to <>. + +You can modify error treatment for these functions using <>. + +PORTABILITY +<> is ANSI C. <> is an extension. +*/ + +/* + * wrapper fmod(x,y) + */ + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double fmod(double x, double y) /* wrapper fmod */ +#else + double fmod(x,y) /* wrapper fmod */ + double x,y; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_fmod(x,y); +#else + double z; + struct exception exc; + z = __ieee754_fmod(x,y); + if(_LIB_VERSION == _IEEE_ ||isnan(y)||isnan(x)) return z; + if(y==0.0) { + /* fmod(x,0) */ + exc.type = DOMAIN; + exc.name = "fmod"; + exc.arg1 = x; + exc.arg2 = y; + exc.err = 0; + if (_LIB_VERSION == _SVID_) + exc.retval = x; + else + exc.retval = 0.0/0.0; + if (_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else + return z; +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/w_log.c b/libjava/java/lang/w_log.c new file mode 100644 index 00000000000..dcc8b9762ec --- /dev/null +++ b/libjava/java/lang/w_log.c @@ -0,0 +1,115 @@ + +/* @(#)w_log.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION + <>, <>---natural logarithms + +INDEX + log +INDEX + logf + +ANSI_SYNOPSIS + #include + double log(double <[x]>); + float logf(float <[x]>); + +TRAD_SYNOPSIS + #include + double log(<[x]>); + double <[x]>; + + float logf(<[x]>); + float <[x]>; + +DESCRIPTION +Return the natural logarithm of <[x]>, that is, its logarithm base e +(where e is the base of the natural system of logarithms, 2.71828@dots{}). +<> and <> are identical save for the return and argument types. + +You can use the (non-ANSI) function <> to specify error +handling for these functions. + +RETURNS +Normally, returns the calculated value. When <[x]> is zero, the +returned value is <<-HUGE_VAL>> and <> is set to <>. +When <[x]> is negative, the returned value is <<-HUGE_VAL>> and +<> is set to <>. You can control the error behavior via +<>. + +PORTABILITY +<> is ANSI, <> is an extension. +*/ + +/* + * wrapper log(x) + */ + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double log(double x) /* wrapper log */ +#else + double log(x) /* wrapper log */ + double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_log(x); +#else + double z; + struct exception exc; + z = __ieee754_log(x); + if(_LIB_VERSION == _IEEE_ || isnan(x) || x > 0.0) return z; +#ifndef HUGE_VAL +#define HUGE_VAL inf + double inf = 0.0; + + SET_HIGH_WORD(inf,0x7ff00000); /* set inf to infinite */ +#endif + exc.name = "log"; + exc.err = 0; + exc.arg1 = x; + exc.arg2 = x; + if (_LIB_VERSION == _SVID_) + exc.retval = -HUGE; + else + exc.retval = -HUGE_VAL; + if(x==0.0) { + /* log(0) */ + exc.type = SING; + if (_LIB_VERSION == _POSIX_) + errno = ERANGE; + else if (!matherr(&exc)) { + errno = EDOM; + } + } else { + /* log(x<0) */ + exc.type = DOMAIN; + if (_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/lang/w_pow.c b/libjava/java/lang/w_pow.c new file mode 100644 index 00000000000..3df099a1714 --- /dev/null +++ b/libjava/java/lang/w_pow.c @@ -0,0 +1,231 @@ + + +/* @(#)w_pow.c 5.2 93/10/01 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION + <>, <>---x to the power y +INDEX + pow +INDEX + powf + + +ANSI_SYNOPSIS + #include + double pow(double <[x]>, double <[y]>); + float pow(float <[x]>, float <[y]>); + +TRAD_SYNOPSIS + #include + double pow(<[x]>, <[y]>); + double <[x]>, <[y]>; + + float pow(<[x]>, <[y]>); + float <[x]>, <[y]>; + +DESCRIPTION + <> and <> calculate <[x]> raised to the exp1.0nt <[y]>. + @tex + (That is, $x^y$.) + @end tex + +RETURNS + On success, <> and <> return the value calculated. + + When the argument values would produce overflow, <> + returns <> and set <> to <>. If the + argument <[x]> passed to <> or <> is a negative + noninteger, and <[y]> is also not an integer, then <> + is set to <>. If <[x]> and <[y]> are both 0, then + <> and <> return <<1>>. + + You can modify error handling for these functions using <>. + +PORTABILITY + <> is ANSI C. <> is an extension. */ + +/* + * wrapper pow(x,y) return x**y + */ + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double pow(double x, double y) /* wrapper pow */ +#else + double pow(x,y) /* wrapper pow */ + double x,y; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_pow(x,y); +#else + double z; +#ifndef HUGE_VAL +#define HUGE_VAL inf + double inf = 0.0; + + SET_HIGH_WORD(inf,0x7ff00000); /* set inf to infinite */ +#endif + struct exception exc; + z=__ieee754_pow(x,y); + if(_LIB_VERSION == _IEEE_|| isnan(y)) return z; + if(isnan(x)) { + if(y==0.0) { + /* pow(NaN,0.0) */ + /* error only if _LIB_VERSION == _SVID_ & _XOPEN_ */ + exc.type = DOMAIN; + exc.name = "pow"; + exc.err = 0; + exc.arg1 = x; + exc.arg2 = y; + exc.retval = x; + if (_LIB_VERSION == _IEEE_ || + _LIB_VERSION == _POSIX_) exc.retval = 1.0; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else + return z; + } + if(x==0.0){ + if(y==0.0) { + /* pow(0.0,0.0) */ + /* error only if _LIB_VERSION == _SVID_ */ + exc.type = DOMAIN; + exc.name = "pow"; + exc.err = 0; + exc.arg1 = x; + exc.arg2 = y; + exc.retval = 0.0; + if (_LIB_VERSION != _SVID_) exc.retval = 1.0; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } + if(finite(y)&&y<0.0) { + /* 0**neg */ + exc.type = DOMAIN; + exc.name = "pow"; + exc.err = 0; + exc.arg1 = x; + exc.arg2 = y; + if (_LIB_VERSION == _SVID_) + exc.retval = 0.0; + else + exc.retval = -HUGE_VAL; + if (_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } + return z; + } + if(!finite(z)) { + if(finite(x)&&finite(y)) { + if(isnan(z)) { + /* neg**non-integral */ + exc.type = DOMAIN; + exc.name = "pow"; + exc.err = 0; + exc.arg1 = x; + exc.arg2 = y; + if (_LIB_VERSION == _SVID_) + exc.retval = 0.0; + else + exc.retval = 0.0/0.0; /* X/Open allow NaN */ + if (_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else { + /* pow(x,y) overflow */ + exc.type = OVERFLOW; + exc.name = "pow"; + exc.err = 0; + exc.arg1 = x; + exc.arg2 = y; + if (_LIB_VERSION == _SVID_) { + exc.retval = HUGE; + y *= 0.5; + if(x<0.0&&rint(y)!=y) exc.retval = -HUGE; + } else { + exc.retval = HUGE_VAL; + y *= 0.5; + if(x<0.0&&rint(y)!=y) exc.retval = -HUGE_VAL; + } + if (_LIB_VERSION == _POSIX_) + errno = ERANGE; + else if (!matherr(&exc)) { + errno = ERANGE; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } + } + } + if(z==0.0&&finite(x)&&finite(y)) { + /* pow(x,y) underflow */ + exc.type = UNDERFLOW; + exc.name = "pow"; + exc.err = 0; + exc.arg1 = x; + exc.arg2 = y; + exc.retval = 0.0; + if (_LIB_VERSION == _POSIX_) + errno = ERANGE; + else if (!matherr(&exc)) { + errno = ERANGE; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } + return z; +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ + + + + + + + + + + + + + + diff --git a/libjava/java/lang/w_remainder.c b/libjava/java/lang/w_remainder.c new file mode 100644 index 00000000000..a06be0e7b30 --- /dev/null +++ b/libjava/java/lang/w_remainder.c @@ -0,0 +1,119 @@ + +/* @(#)w_remainder.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION +<>, <>, <>, <>---round and remainder +INDEX + rint +INDEX + rintf +INDEX + remainder +INDEX + remainderf + +ANSI_SYNOPSIS + #include + double rint(double <[x]>); + float rintf(float <[x]>); + double remainder(double <[x]>, double <[y]>); + float remainderf(float <[x]>, float <[y]>); + +TRAD_SYNOPSIS + #include + double rint(<[x]>) + double <[x]>; + float rintf(<[x]>) + float <[x]>; + double remainder(<[x]>,<[y]>) + double <[x]>, <[y]>; + float remainderf(<[x]>,<[y]>) + float <[x]>, <[y]>; + +DESCRIPTION +<> and <> returns their argument rounded to the nearest +integer. <> and <> find the remainder of +<[x]>/<[y]>; this value is in the range -<[y]>/2 .. +<[y]>/2. + +RETURNS +<> and <> return the integer result as a double. + +PORTABILITY +<> and <> are System V release 4. <> and +<> are extensions. + +*/ + +/* + * wrapper remainder(x,p) + */ + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double remainder(double x, double y) /* wrapper remainder */ +#else + double remainder(x,y) /* wrapper remainder */ + double x,y; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_remainder(x,y); +#else + double z; + struct exception exc; + z = __ieee754_remainder(x,y); + if(_LIB_VERSION == _IEEE_ || isnan(y)) return z; + if(y==0.0) { + /* remainder(x,0) */ + exc.type = DOMAIN; + exc.name = "remainder"; + exc.err = 0; + exc.arg1 = x; + exc.arg2 = y; + exc.retval = 0.0/0.0; + if (_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else + return z; +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ + + + + + + + + + + + + + + + + + diff --git a/libjava/java/lang/w_sqrt.c b/libjava/java/lang/w_sqrt.c new file mode 100644 index 00000000000..23a793ce74a --- /dev/null +++ b/libjava/java/lang/w_sqrt.c @@ -0,0 +1,93 @@ + +/* @(#)w_sqrt.c 5.1 93/09/24 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* +FUNCTION + <>, <>---positive square root + +INDEX + sqrt +INDEX + sqrtf + +ANSI_SYNOPSIS + #include + double sqrt(double <[x]>); + float sqrtf(float <[x]>); + +TRAD_SYNOPSIS + #include + double sqrt(<[x]>); + float sqrtf(<[x]>); + +DESCRIPTION + <> computes the positive square root of the argument. + You can modify error handling for this function with + <>. + +RETURNS + On success, the square root is returned. If <[x]> is real and + positive, then the result is positive. If <[x]> is real and + negative, the global value <> is set to <> (domain error). + + +PORTABILITY + <> is ANSI C. <> is an extension. +*/ + +/* + * wrapper sqrt(x) + */ + +#include "fdlibm.h" +#include + +#ifndef _DOUBLE_IS_32BITS + +#ifdef __STDC__ + double sqrt(double x) /* wrapper sqrt */ +#else + double sqrt(x) /* wrapper sqrt */ + double x; +#endif +{ +#ifdef _IEEE_LIBM + return __ieee754_sqrt(x); +#else + struct exception exc; + double z; + z = __ieee754_sqrt(x); + if(_LIB_VERSION == _IEEE_ || isnan(x)) return z; + if(x<0.0) { + exc.type = DOMAIN; + exc.name = "sqrt"; + exc.err = 0; + exc.arg1 = exc.arg2 = x; + if (_LIB_VERSION == _SVID_) + exc.retval = 0.0; + else + exc.retval = 0.0/0.0; + if (_LIB_VERSION == _POSIX_) + errno = EDOM; + else if (!matherr(&exc)) { + errno = EDOM; + } + if (exc.err != 0) + errno = exc.err; + return exc.retval; + } else + return z; +#endif +} + +#endif /* defined(_DOUBLE_IS_32BITS) */ diff --git a/libjava/java/net/BindException.java b/libjava/java/net/BindException.java new file mode 100644 index 00000000000..5f7b4919b40 --- /dev/null +++ b/libjava/java/net/BindException.java @@ -0,0 +1,35 @@ +// BindException.java + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public class BindException extends SocketException +{ + public BindException() + { + super(); + } + + public BindException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/net/ConnectException.java b/libjava/java/net/ConnectException.java new file mode 100644 index 00000000000..d4d3a48cc68 --- /dev/null +++ b/libjava/java/net/ConnectException.java @@ -0,0 +1,35 @@ +// ConnectException.java + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public class ConnectException extends SocketException +{ + public ConnectException() + { + super(); + } + + public ConnectException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/net/ContentHandler.java b/libjava/java/net/ContentHandler.java new file mode 100644 index 00000000000..fd2e3b12f48 --- /dev/null +++ b/libjava/java/net/ContentHandler.java @@ -0,0 +1,29 @@ +// ContentHandler.java - Superclass of classes that read from a URLConnection. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +import java.io.IOException; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public abstract class ContentHandler +{ + public abstract Object getContent(URLConnection urlc) throws IOException; +} diff --git a/libjava/java/net/ContentHandlerFactory.java b/libjava/java/net/ContentHandlerFactory.java new file mode 100644 index 00000000000..ee6dcffdb69 --- /dev/null +++ b/libjava/java/net/ContentHandlerFactory.java @@ -0,0 +1,27 @@ +// ContentHandlerFactory.java - Abstract Content Handler factory. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public abstract interface ContentHandlerFactory +{ + public ContentHandler createContentHandler(String mimetype); +} diff --git a/libjava/java/net/FileNameMap.java b/libjava/java/net/FileNameMap.java new file mode 100644 index 00000000000..24e8ef894f1 --- /dev/null +++ b/libjava/java/net/FileNameMap.java @@ -0,0 +1,27 @@ +// FileNameMap.java - Abstract interface to map from a File Name to MIME type. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public abstract interface FileNameMap +{ + public String getContentTypeFor(String fileName); +} diff --git a/libjava/java/net/HttpURLConnection.java b/libjava/java/net/HttpURLConnection.java new file mode 100644 index 00000000000..8b05b73ebbb --- /dev/null +++ b/libjava/java/net/HttpURLConnection.java @@ -0,0 +1,174 @@ +// HttpURLConnection.java - Subclass of communications links using +// Hypertext Transfer Protocol. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +import java.io.*; + +/** + * @author Warren Levy + * @date March 29, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public abstract class HttpURLConnection extends URLConnection +{ + /* HTTP Success Response Codes */ + public static final int HTTP_OK = 200; + public static final int HTTP_CREATED = 201; + public static final int HTTP_ACCEPTED = 202; + public static final int HTTP_NOT_AUTHORITATIVE = 203; + public static final int HTTP_NO_CONTENT = 204; + public static final int HTTP_RESET = 205; + public static final int HTTP_PARTIAL = 206; + + /* HTTP Redirection Response Codes */ + public static final int HTTP_MULT_CHOICE = 300; + public static final int HTTP_MOVED_PERM = 301; + public static final int HTTP_MOVED_TEMP = 302; + public static final int HTTP_SEE_OTHER = 303; + public static final int HTTP_NOT_MODIFIED = 304; + public static final int HTTP_USE_PROXY = 305; + + /* HTTP Client Error Response Codes */ + public static final int HTTP_BAD_REQUEST = 400; + public static final int HTTP_UNAUTHORIZED = 401; + public static final int HTTP_PAYMENT_REQUIRED = 402; + public static final int HTTP_FORBIDDEN = 403; + public static final int HTTP_NOT_FOUND = 404; + public static final int HTTP_BAD_METHOD = 405; + public static final int HTTP_NOT_ACCEPTABLE = 406; + public static final int HTTP_PROXY_AUTH = 407; + public static final int HTTP_CLIENT_TIMEOUT = 408; + public static final int HTTP_CONFLICT = 409; + public static final int HTTP_GONE = 410; + public static final int HTTP_LENGTH_REQUIRED = 411; + public static final int HTTP_PRECON_FAILED = 412; + public static final int HTTP_ENTITY_TOO_LARGE = 413; + public static final int HTTP_REQ_TOO_LONG = 414; + public static final int HTTP_UNSUPPORTED_TYPE = 415; + + /* HTTP Server Error Response Codes */ + public static final int HTTP_SERVER_ERROR = 500; + public static final int HTTP_INTERNAL_ERROR = 501; + public static final int HTTP_BAD_GATEWAY = 502; + public static final int HTTP_UNAVAILABLE = 503; + public static final int HTTP_GATEWAY_TIMEOUT = 504; + public static final int HTTP_VERSION = 505; + + protected String method = "GET"; + protected int responseCode = -1; + protected String responseMessage; + + static boolean followRedirects = true; + + protected HttpURLConnection(URL url) + { + super(url); + } + + public abstract void disconnect(); + + public abstract boolean usingProxy(); + + public static void setFollowRedirects(boolean set) + { + // Throw an exception if an extant security mgr precludes + // setting the factory. + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkSetFactory(); + + followRedirects = set; + } + + public static boolean getFollowRedirects() + { + return followRedirects; + } + + public void setRequestMethod(String method) throws ProtocolException + { + if (connected) + throw new ProtocolException("Already connected"); + + if (method.equals("GET") || method.equals("POST") || + method.equals("HEAD") || method.equals("OPTIONS") || + method.equals("PUT") || method.equals("DELETE") || + method.equals("TRACE")) + this.method = method; + else + throw new ProtocolException("Invalid HTTP request method"); + } + + public String getRequestMethod() + { + return method; + } + + public int getResponseCode() throws IOException + { + getResponseVals(); + return responseCode; + } + + public String getResponseMessage() throws IOException + { + getResponseVals(); + return responseMessage; + } + + private void getResponseVals() throws IOException + { + // Response is the first header received from the connection. + String respField = getHeaderField(0); + if (! respField.startsWith("HTTP/")) + { + // Set to default values on failure. + responseCode = -1; + responseMessage = null; + return; + } + + int firstSpc, nextSpc; + firstSpc = respField.indexOf(' '); + nextSpc = respField.indexOf(' ', firstSpc + 1); + responseMessage = respField.substring(nextSpc + 1); + String codeStr = respField.substring(firstSpc + 1, nextSpc); + try + { + responseCode = Integer.parseInt(codeStr); + } + catch (NumberFormatException e) + { + // Set to default values on failure. + responseCode = -1; + responseMessage = null; + } + if (responseCode == HTTP_NOT_FOUND) + throw new FileNotFoundException(url.toString()); + else if (responseCode >= 400) + throw new IOException(url.toString() + " " + respField); + } + + // TODO12: public Permission getPermission() throws IOException + // { + // } + + // TODO12: public InputStream getErrorStream() + // { + // } +} diff --git a/libjava/java/net/InetAddress.java b/libjava/java/net/InetAddress.java new file mode 100644 index 00000000000..baf5153e933 --- /dev/null +++ b/libjava/java/net/InetAddress.java @@ -0,0 +1,255 @@ +// INetAddress.java -- An Internet Protocol (IP) address. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Per Bothner + * @date January 6, 1999. + */ + +/* + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * (The latter turns out to have some errors ...) + * Status: Believed complete and correct. + */ + +public final class InetAddress +{ + String hostname; + byte[] address; + + InetAddress (byte[] address, String hostname) + { + this.address = address; + this.hostname = hostname; + } + + public boolean isMulticastAddress () + { + int len = address.length; + if (len == 4) + return (address[0] & 0xF0) == 0xE0; + if (len == 16) + return address[0] == (byte) 0xFF; + return false; + } + + public String getHostName () + { + if (hostname == null) + lookup (null, this, false); + return hostname; + } + + public byte[] getAddress () + { + // An experiment shows that JDK1.2 returns a different byte array each + // time. This makes sense, in terms of security. + return (byte[]) address.clone(); + } + + /* Helper function due to a CNI limitation. */ + private static InetAddress[] allocArray (int count) + { + return new InetAddress[count]; + } + + /* Helper function due to a CNI limitation. */ + private static SecurityException checkConnect (String hostname) + { + SecurityManager s = System.getSecurityManager(); + if (s == null) + return null; + try + { + s.checkConnect(hostname, -1); + return null; + } + catch (SecurityException ex) + { + return ex; + } + } + + public String getHostAddress () + { + StringBuffer sbuf = new StringBuffer(40); + int len = address.length; + int i = 0; + if (len == 16) + { // An IPv6 address. + for (; ; i += 2) + { + if (i >= 16) + return sbuf.toString(); + int x = ((address[i] & 0xFF) << 8) | (address[i+1] & 0xFF); + boolean empty = sbuf.length() == 0; + if (empty) + { + if (i == 10 && x == 0xFFFF) + { // IPv4-mapped IPv6 address. + sbuf.append(":FFFF:"); + break; // Continue as IPv4 address; + } + else if (i == 12) + { // IPv4-compatible IPv6 address. + sbuf.append(':'); + break; // Continue as IPv4 address. + } + else if (i > 0) + sbuf.append("::"); + } + else + sbuf.append(':'); + if (x != 0 || i >= 14) + sbuf.append(Integer.toHexString(x).toUpperCase()); + } + } + for ( ; ; ) + { + sbuf.append(address[i] & 0xFF); + i++; + if (i == len) + break; + sbuf.append('.'); + } + return sbuf.toString(); + } + + public int hashCode() + { + // There hashing algorithm is not specified, but a simple experiment + // shows that it is equal to the address, as a 32-bit big-endian integer. + int hash = 0; + int len = address.length; + int i = len > 4 ? len - 4 : 0; + for ( ; i < len; i++) + hash = (hash << 8) | (address[i] & 0xFF); + return hash; + } + + public boolean equals (Object obj) + { + if (obj == null || ! (obj instanceof InetAddress)) + return false; + // "The Java Class Libraries" 2nd edition says "If a machine has + // multiple names instances of InetAddress for different name of + // that same machine are not equal. This is because they have + // different host names." This violates the description in the + // JDK 1.2 API documentation. A little experiementation + // shows that the latter is correct. + byte[] addr1 = address; + byte[] addr2 = ((InetAddress) obj).address; + if (addr1.length != addr2.length) + return false; + for (int i = addr1.length; --i >= 0; ) + if (addr1[i] != addr2[i]) + return false; + return true; + } + + public String toString() + { + return getHostName()+'/'+getHostAddress(); + } + + /** If host is a valid numeric IP address, return the numeric address. + * Otherwise, return null. */ + private static native byte[] aton (String host); + + private static native InetAddress[] lookup + (String hostname, InetAddress addr, boolean all); + + public static InetAddress getByName (String host) + throws UnknownHostException + { + if (host == null) + return getLocalHost(); + byte[] address = aton(host); + if (address != null) + return new InetAddress(address, null); + InetAddress iaddr = new InetAddress(null, null); + lookup(host, iaddr, false); + return iaddr; + } + + public static InetAddress[] getAllByName (String host) + throws UnknownHostException + { + byte[] address = aton(host); + if (address != null) + { + InetAddress[] result = new InetAddress[1]; + result[0] = new InetAddress(address, null); + return result; + } + return lookup(host, null, true); + } + + private static final byte[] localhostAddress = { 127, 0, 0, 1 }; + + private static native String getLocalHostname (); + + private static InetAddress localhost = null; + + public static InetAddress getLocalHost() throws UnknownHostException + { + SecurityManager s = System.getSecurityManager(); + // Experimentation shows that JDK1.2 does cache the result. + // However, if there is a security manager, and the cached result + // is other than "localhost", we need to check again. + if (localhost == null + || (s != null && localhost.address != localhostAddress)) + getLocalHost(s); + return localhost; + } + + private static synchronized void getLocalHost(SecurityManager s) + throws UnknownHostException + { + // Check the localhost cache again, now that we've synchronized. + if (s == null && localhost != null) + return; + String hostname = getLocalHostname(); + if (s != null) + { + // "The Java Class Libraries" suggests that if the security + // manager disallows getting the local host name, then + // we use the loopback host. + // However, the JDK 1.2 API claims to throw SecurityException, + // which seems to suggest SecurityException is *not* caught. + // In this case, experimentation shows that former is correct. + try + { + // This is wrong, if the name returned from getLocalHostname() + // is not a fully qualified name. FIXME. + s.checkConnect(hostname, -1); + } + catch (SecurityException ex) + { + hostname = null; + } + } + if (hostname != null) + { + try + { + localhost = getByName(hostname); + } + catch (Exception ex) + { + } + } + if (localhost == null) + localhost = new InetAddress (localhostAddress, "localhost"); + } +} diff --git a/libjava/java/net/MalformedURLException.java b/libjava/java/net/MalformedURLException.java new file mode 100644 index 00000000000..a5a8db586b2 --- /dev/null +++ b/libjava/java/net/MalformedURLException.java @@ -0,0 +1,35 @@ +// MalformedURLException.java + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public class MalformedURLException extends java.io.IOException +{ + public MalformedURLException() + { + super(); + } + + public MalformedURLException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/net/NoRouteToHostException.java b/libjava/java/net/NoRouteToHostException.java new file mode 100644 index 00000000000..dc01688ab3f --- /dev/null +++ b/libjava/java/net/NoRouteToHostException.java @@ -0,0 +1,35 @@ +// NoRouteToHostException.java + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public class NoRouteToHostException extends SocketException +{ + public NoRouteToHostException() + { + super(); + } + + public NoRouteToHostException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/net/PlainSocketImpl.java b/libjava/java/net/PlainSocketImpl.java new file mode 100644 index 00000000000..5bc2caef042 --- /dev/null +++ b/libjava/java/net/PlainSocketImpl.java @@ -0,0 +1,64 @@ +// natClass.cc - Implementation of java.lang.Class native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; +import java.io.*; + +class PlainSocketImpl extends SocketImpl +{ + int fnum = -1; + + protected native void create (boolean stream) throws IOException; + + protected void connect (String host, int port) throws IOException + { + connect(InetAddress.getByName(host), port); + } + + protected native void connect (InetAddress host, int port) + throws IOException; + + protected native void bind (InetAddress host, int port) throws IOException; + + protected native void listen (int backlog) throws IOException; + + private native void accept (PlainSocketImpl s) throws IOException; + protected void accept (SocketImpl s) throws IOException + { + accept((PlainSocketImpl) s); + } + + private InputStream in; + private OutputStream out; + + protected InputStream getInputStream() throws IOException + { + if (in == null) + in = new FileInputStream (fd); + return in; + } + + protected OutputStream getOutputStream() throws IOException + { + if (out == null) + out = new FileOutputStream (fd); + return out; + } + + protected int available () throws IOException + { + return in.available(); + } + + protected void close () throws IOException + { + fd.close(); + } +} diff --git a/libjava/java/net/ProtocolException.java b/libjava/java/net/ProtocolException.java new file mode 100644 index 00000000000..f7db6852edd --- /dev/null +++ b/libjava/java/net/ProtocolException.java @@ -0,0 +1,35 @@ +// ProtocolException.java + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public class ProtocolException extends java.io.IOException +{ + public ProtocolException() + { + super(); + } + + public ProtocolException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/net/ServerSocket.java b/libjava/java/net/ServerSocket.java new file mode 100644 index 00000000000..e4b50693e75 --- /dev/null +++ b/libjava/java/net/ServerSocket.java @@ -0,0 +1,105 @@ +// Socket.java + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/** + * @author Per Bothner + * @date January 6, 1999. + */ + +/** Written using on-line Java Platform 1.2 API Specification. + * Status: I believe all methods are implemented, but many + * of them just throw an exception. + */ + +package java.net; +import java.io.*; + +public class ServerSocket +{ + static SocketImplFactory factory; + SocketImpl impl; + + public ServerSocket (int port) + throws java.io.IOException + { + this(port, 5); + } + + public ServerSocket (int port, int backlog) + throws java.io.IOException + { + this(port, backlog, InetAddress.getLocalHost()); + } + + public ServerSocket (int port, int backlog, InetAddress bindAddr) + throws java.io.IOException + { + if (factory == null) + this.impl = new PlainSocketImpl(); + else + this.impl = factory.createSocketImpl(); + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkListen(port); + impl.create(true); + impl.bind(bindAddr, port); + impl.listen(backlog); + } + + public InetAddress getInetAddress() + { + return impl.getInetAddress(); + } + + public int getLocalPort() + { + return impl.getLocalPort(); + } + + public Socket accept () throws IOException + { + Socket s = new Socket(Socket.factory == null ? new PlainSocketImpl() + : Socket.factory.createSocketImpl()); + implAccept (s); + return s; + } + + protected final void implAccept (Socket s) throws IOException + { + impl.accept(s.impl); + } + + public void close () throws IOException + { + impl.close(); + } + + public void setSoTimeout (int timeout) throws SocketException + { + throw new InternalError("ServerSocket.setSoTimeout not implemented"); + } + + public int getSoTimeout () throws SocketException + { + throw new InternalError("ServerSocket.getSoTimeout not implemented"); + } + + public String toString () + { + return impl.toString(); + } + + public static void setSocketImplFactory (SocketImplFactory fac) + throws IOException + { + factory = fac; + } + +} diff --git a/libjava/java/net/Socket.java b/libjava/java/net/Socket.java new file mode 100644 index 00000000000..8c027d9f88f --- /dev/null +++ b/libjava/java/net/Socket.java @@ -0,0 +1,209 @@ +// Socket.java + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/** + * @author Per Bothner + * @date January 6, 1999. + */ + +/** Written using on-line Java Platform 1.2 API Specification. + * Status: I believe all methods are implemented, but many + * of them just throw an exception. + */ + +package java.net; +import java.io.*; + +public class Socket +{ + static SocketImplFactory factory; + SocketImpl impl; + + protected Socket () + { + } + + protected Socket (SocketImpl impl) throws SocketException + { + this.impl = impl; + } + + public Socket (String host, int port) + throws UnknownHostException, IOException + { + this(factory == null ? new PlainSocketImpl() : factory.createSocketImpl()); + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkConnect(host, port); + impl.create(true); + impl.connect(host, port); + } + + public Socket (InetAddress address, int port) + throws IOException + { + this(factory == null ? new PlainSocketImpl() : factory.createSocketImpl()); + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkConnect(address.getHostName(), port); + impl.create(true); + impl.connect(address, port); + } + + public Socket (String host, int port, + InetAddress localAddr, int localPort) throws IOException + { + this(factory == null ? new PlainSocketImpl() : factory.createSocketImpl()); + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkConnect(host, port); + impl.create(true); + impl.bind(localAddr, localPort); + impl.connect(host, port); + } + + public Socket (InetAddress address, int port, + InetAddress localAddr, int localPort) throws IOException + { + this(factory == null ? new PlainSocketImpl() : factory.createSocketImpl()); + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkConnect(address.getHostName(), port); + impl.create(true); + impl.bind(localAddr, localPort); + impl.connect(address, port); + } + + /** + * @deprecated Use DatagramSocket instead for UDP transport. + */ + public Socket (String host, int port, boolean stream) throws IOException + { + impl = factory == null ? new PlainSocketImpl() + : factory.createSocketImpl(); + impl.create(stream); + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkConnect(host, port); + impl.connect(host, port); + } + + /** + * @deprecated Use DatagramSocket instead for UDP transport. + */ + public Socket (InetAddress host, int port, boolean stream) throws IOException + { + impl = factory == null ? new PlainSocketImpl() + : factory.createSocketImpl(); + impl.create(stream); + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkConnect(host.getHostName(), port); + impl.connect(host, port); + } + + public InetAddress getInetAddress () + { + return impl.getInetAddress(); + } + + public InetAddress getLocalAddress () + { + // There doesn't seem to be any way to implement this + // using a (generic) SocketImpl ... What am I missing? + throw new InternalError("Socket.getLocalAddres not implemented"); + } + + public int getPort () + { + return impl.getPort(); + } + + public int getLocalPort () + { + return impl.getLocalPort(); + } + + public InputStream getInputStream () throws IOException + { + return impl.getInputStream(); + } + + public OutputStream getOutputStream () throws IOException + { + return impl.getOutputStream(); + } + + public void setTcpNoDelay (boolean on) throws SocketException + { + throw new InternalError("Socket.setTcpNoDelay not implemented"); + } + + public boolean getTcpNoDelay() throws SocketException + { + throw new InternalError("Socket.getTcpNoDelay not implemented"); + } + + public void setSoLinger(boolean on, int linger) throws SocketException + { + throw new InternalError("Socket.setSoLinger not implemented"); + } + + public boolean getSoLinger() throws SocketException + { + throw new InternalError("Socket.getSoLinger not implemented"); + } + + public void setSoTimeout (int timeout) throws SocketException + { + throw new InternalError("Socket.setSoTimeout not implemented"); + } + + public int getSoTimeout () throws SocketException + { + throw new InternalError("Socket.getSoTimeout not implemented"); + } + + public void setSendBufferSize (int size) throws SocketException + { + throw new InternalError("Socket.setSendBufferSize not implemented"); + } + + public int getSendBufferSize () throws SocketException + { + throw new InternalError("Socket.getSendBufferSize not implemented"); + } + + public void setReceiveBufferSize (int size) throws SocketException + { + throw new InternalError("Socket.setReceiveBufferSize not implemented"); + } + + public int getReceiveBufferSize () throws SocketException + { + throw new InternalError("Socket.getReceiveBufferSize not implemented"); + } + + public void close () throws IOException + { + impl.close(); + } + + public String toString () + { + return impl.toString(); + } + + public static void setSocketImplFactory (SocketImplFactory fac) + throws IOException + { + factory = fac; + } +} diff --git a/libjava/java/net/SocketException.java b/libjava/java/net/SocketException.java new file mode 100644 index 00000000000..24a50ef3f75 --- /dev/null +++ b/libjava/java/net/SocketException.java @@ -0,0 +1,33 @@ +// SocketException.java - Base class for networking exceptions + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Per Bothner + * @date January 6, 1999. + */ + +/** Written using on-line Java Platform 1.2 API Specification. + * Believed complete and correct. + */ + +public class SocketException extends java.io.IOException +{ + public SocketException () + { + super(); + } + + public SocketException (String s) + { + super(s); + } +} diff --git a/libjava/java/net/SocketImpl.java b/libjava/java/net/SocketImpl.java new file mode 100644 index 00000000000..5ad311811d8 --- /dev/null +++ b/libjava/java/net/SocketImpl.java @@ -0,0 +1,70 @@ +// SocketImpl.java - Abstract socket implementation. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; +import java.io.*; + +/** + * @author Per Bothner + * @date January 6, 1999. + */ + +/** Written using on-line Java Platform 1.2 API Specification. + * Believed complete and correct, except for implementation of toString. + */ + +public abstract class SocketImpl +{ + protected InetAddress address; + + protected FileDescriptor fd; + + protected int localport; + + protected int port; + + public SocketImpl () + { + } + + protected abstract void create (boolean stream) throws IOException; + + protected abstract void connect (String host, int port) throws IOException; + + protected abstract void connect (InetAddress host, int port) + throws IOException; + + protected abstract void bind (InetAddress host, int port) throws IOException; + + protected abstract void listen (int backlog) throws IOException; + + protected abstract void accept (SocketImpl s) throws IOException; + + protected abstract InputStream getInputStream() throws IOException; + + protected abstract OutputStream getOutputStream() throws IOException; + + protected abstract int available () throws IOException; + + protected abstract void close () throws IOException; + + protected FileDescriptor getFileDescriptor () { return fd; } + + protected InetAddress getInetAddress () { return address; } + + protected int getPort () { return port; } + + protected int getLocalPort () { return localport; } + + public String toString () + { + return super.toString(); // FIXME + } +} diff --git a/libjava/java/net/SocketImplFactory.java b/libjava/java/net/SocketImplFactory.java new file mode 100644 index 00000000000..7631ab8fd1f --- /dev/null +++ b/libjava/java/net/SocketImplFactory.java @@ -0,0 +1,25 @@ +// SocketImplFactory.java - Abstract socket implementation factory. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Per Bothner + * @date January 6, 1999. + */ + +/** Written using on-line Java Platform 1.2 API Specification. + * Status: Believed complete and correct. + */ + +public abstract interface SocketImplFactory +{ + public SocketImpl createSocketImpl (); +} diff --git a/libjava/java/net/URL.java b/libjava/java/net/URL.java new file mode 100644 index 00000000000..da56f49dc2d --- /dev/null +++ b/libjava/java/net/URL.java @@ -0,0 +1,341 @@ +// URL.java - A Uniform Resource Locator. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +import java.io.*; +import java.util.Hashtable; +import java.util.StringTokenizer; + +/** + * @author Warren Levy + * @date March 4, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public final class URL implements Serializable +{ + private String protocol; + private String host; + private int port; + private String file; + private String ref; + private URLStreamHandler handler; + private static Hashtable handlers = new Hashtable(); + private static URLStreamHandlerFactory factory; + + public URL(String protocol, String host, int port, String file) + throws MalformedURLException + { + this(protocol, host, port, file, null); + } + + public URL(String protocol, String host, String file) + throws MalformedURLException + { + this(protocol, host, -1, file, null); + } + + // JDK1.2 + public URL(String protocol, String host, int port, String file, + URLStreamHandler handler) throws MalformedURLException + { + if (protocol == null) + throw new MalformedURLException("null protocol"); + this.protocol = protocol; + + if (handler != null) + { + // TODO12: Need SecurityManager.checkPermission and + // TODO12: java.net.NetPermission from JDK 1.2 to be implemented. + // Throw an exception if an extant security mgr precludes + // specifying a StreamHandler. + // + // SecurityManager s = System.getSecurityManager(); + // if (s != null) + // s.checkPermission(NetPermission("specifyStreamHandler")); + + this.handler = handler; + } + else + this.handler = setURLStreamHandler(protocol); + + if (this.handler == null) + throw new MalformedURLException("Handler for protocol not found"); + + this.host = host; + + this.port = port; + + int hashAt = file.indexOf('#'); + if (hashAt < 0) + { + this.file = file; + this.ref = null; + } + else + { + this.file = file.substring(0, hashAt); + this.ref = file.substring(hashAt + 1); + } + } + + public URL(String spec) throws MalformedURLException + { + this((URL) null, spec, (URLStreamHandler) null); + } + + public URL(URL context, String spec) throws MalformedURLException + { + this(context, spec, (URLStreamHandler) null); + } + + // JDK1.2 + public URL(URL context, String spec, URLStreamHandler handler) + throws MalformedURLException + { + /* A protocol is defined by the doc as the substring before a ':' + * as long as the ':' occurs before any '/'. + * + * If context is null, then spec must be an absolute URL. + * + * The relative URL need not specify all the components of a URL. + * If the protocol, host name, or port number is missing, the value + * is inherited from the context. A bare file component is appended + * to the context's file. The optional anchor is not inherited. + */ + + int colon; + int slash; + if ((colon = spec.indexOf(':')) > 0 && + (colon < (slash = spec.indexOf('/')) || slash < 0)) + { + // Protocol specified in spec string. + protocol = spec.substring(0, colon); + if (context != null && context.protocol == protocol) + { + // The 1.2 doc specifically says these are copied to the new URL. + host = context.host; + port = context.port; + file = context.file; + } + } + else if (context != null) + { + // Protocol NOT specified in spec string. + // Use context fields (except ref) as a foundation for relative URLs. + colon = -1; + protocol = context.protocol; + host = context.host; + port = context.port; + file = context.file; + } + else // Protocol NOT specified in spec. and no context available. + throw new + MalformedURLException("Absolute URL required with null context"); + + if (handler != null) + { + // TODO12: Need SecurityManager.checkPermission and + // TODO12: java.net.NetPermission from JDK 1.2 to be implemented. + // Throw an exception if an extant security mgr precludes + // specifying a StreamHandler. + // + // SecurityManager s = System.getSecurityManager(); + // if (s != null) + // s.checkPermission(NetPermission("specifyStreamHandler")); + + this.handler = handler; + } + else + this.handler = setURLStreamHandler(protocol); + + if (this.handler == null) + throw new MalformedURLException("Handler for protocol not found"); + + // JDK 1.2 doc for parseURL specifically states that any '#' ref + // is to be excluded by passing the 'limit' as the indexOf the '#' + // if one exists, otherwise pass the end of the string. + int hashAt = spec.indexOf('#', colon + 1); + this.handler.parseURL(this, spec, colon + 1, + hashAt < 0 ? spec.length() : hashAt); + if (hashAt >= 0) + ref = spec.substring(hashAt + 1); + } + + public boolean equals(Object obj) + { + if (obj == null || ! (obj instanceof URL)) + return false; + + URL uObj = (URL) obj; + if (protocol != uObj.protocol || host != uObj.host || port != uObj.port || + file != uObj.file || ref != uObj.ref) + return false; + + return true; + } + + public final Object getContent() throws IOException + { + return openConnection().getContent(); + } + + public String getFile() + { + return file; + } + + public String getHost() + { + return host; + } + + public int getPort() + { + return port; + } + + public String getProtocol() + { + return protocol; + } + + public String getRef() + { + return ref; + } + + public int hashCode() + { + // JCL book says this is computed using (only) the hashcodes of the + // protocol, host and file fields. Empirical evidence indicates this + // is probably XOR. + return (protocol.hashCode() ^ host.hashCode() ^ file.hashCode()); + } + + public URLConnection openConnection() throws IOException + { + return handler.openConnection(this); + } + + public final InputStream openStream() throws IOException + { + return openConnection().getInputStream(); + } + + public boolean sameFile(URL other) + { + if (other == null || protocol != other.protocol || host != other.host || + port != other.port || file != other.file) + return false; + + return true; + } + + protected void set(String protocol, String host, int port, String file, + String ref) + { + // TBD: Theoretically, a poorly written StreamHandler could pass an + // invalid protocol. It will cause the handler to be set to null + // thus overriding a valid handler. Callers of this method should + // be aware of this. + this.handler = setURLStreamHandler(protocol); + this.protocol = protocol; + this.port = port; + this.host = host; + this.file = file; + this.ref = ref; + } + + public static synchronized void + setURLStreamHandlerFactory(URLStreamHandlerFactory fac) + { + if (factory != null) + throw new Error("URLStreamHandlerFactory already set"); + + // Throw an exception if an extant security mgr precludes + // setting the factory. + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkSetFactory(); + factory = fac; + } + + public String toExternalForm() + { + // Identical to toString(). + return handler.toExternalForm(this); + } + + public String toString() + { + // Identical to toExternalForm(). + return handler.toExternalForm(this); + } + + private URLStreamHandler setURLStreamHandler(String protocol) + { + URLStreamHandler handler; + + // See if a handler has been cached for this protocol. + if ((handler = (URLStreamHandler) handlers.get(protocol)) != null) + return handler; + + // If a non-default factory has been set, use it to find the protocol. + if (factory != null) + handler = factory.createURLStreamHandler(protocol); + + // Non-default factory may have returned null or a factory wasn't set. + // Use the default search algorithm to find a handler for this protocol. + if (handler == null) + { + // Get the list of packages to check and append our default handler + // to it, along with the JDK specified default as a last resort. + // Except in very unusual environments the JDK specified one shouldn't + // ever be needed (or available). + String propVal = System.getProperty("java.protocol.handler.pkgs"); + propVal = (propVal == null) ? "" : (propVal + "|"); + propVal = propVal + "gnu.gcj.protocol|sun.net.www.protocol"; + + StringTokenizer pkgPrefix = new StringTokenizer(propVal, "|"); + do + { + String facName = pkgPrefix.nextToken() + "." + protocol + + ".Handler"; + try + { + handler = + (URLStreamHandler) Class.forName(facName).newInstance(); + } + catch (Exception e) + { + // Can't instantiate; handler still null, go on to next element. + } + } while ((handler == null || + ! (handler instanceof URLStreamHandler)) && + pkgPrefix.hasMoreTokens()); + } + + // Update the hashtable with the new protocol handler. + if (handler != null) + if (handler instanceof URLStreamHandler) + handlers.put(protocol, handler); + else + handler = null; + + return handler; + } +} diff --git a/libjava/java/net/URLConnection.java b/libjava/java/net/URLConnection.java new file mode 100644 index 00000000000..12e8a8b4cc6 --- /dev/null +++ b/libjava/java/net/URLConnection.java @@ -0,0 +1,423 @@ +// URLConnection.java - Superclass of all communications links between +// an application and a URL. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +import java.io.*; +import java.text.ParsePosition; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Locale; +import java.util.Hashtable; +import java.util.StringTokenizer; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Two guessContentTypeFrom... methods not implemented. + * getContent method assumes content type from response; see comment there. + */ + +public abstract class URLConnection +{ + protected URL url; + protected boolean doInput = true; + protected boolean doOutput = false; + protected boolean allowUserInteraction; + protected boolean useCaches; + protected long ifModifiedSince = 0L; + protected boolean connected = false; + private static boolean defaultAllowUserInteraction = false; + private static boolean defaultUseCaches = true; + private static FileNameMap fileNameMap; // Set by the URLConnection subclass. + private static ContentHandlerFactory factory; + private static ContentHandler contentHandler; + private static Hashtable handlers = new Hashtable(); + private static Locale locale = new Locale("En", "Us", "Unix"); + private static SimpleDateFormat dateFormat1 = + new SimpleDateFormat("EEE, dd MMM yyyy hh:mm:ss 'GMT'", locale); + private static SimpleDateFormat dateFormat2 = + new SimpleDateFormat("EEEE, dd-MMM-yy hh:mm:ss 'GMT'", locale); + private static SimpleDateFormat dateFormat3 = + new SimpleDateFormat("EEE MMM d hh:mm:ss yyyy", locale); + + protected URLConnection(URL url) + { + this.url = url; + allowUserInteraction = defaultAllowUserInteraction; + useCaches = defaultUseCaches; + } + + public abstract void connect() throws IOException; + + public URL getURL() + { + return url; + } + + public int getContentLength() + { + return getHeaderFieldInt("content-length", -1); + } + + public String getContentType() + { + return getHeaderField("content-type"); + } + + public String getContentEncoding() + { + return getHeaderField("content-encoding"); + } + + public long getExpiration() + { + return getHeaderFieldDate("expiration", 0L); + } + + public long getDate() + { + return getHeaderFieldDate("date", 0L); + } + + public long getLastModified() + { + return getHeaderFieldDate("last-modified", 0L); + } + + public String getHeaderField(int n) + { + // Subclasses for specific protocols override this. + return null; + } + + public String getHeaderField(String name) + { + // Subclasses for specific protocols override this. + return null; + } + + public int getHeaderFieldInt(String name, int val) + { + String str = getHeaderField(name); + try + { + if (str != null) + val = Integer.parseInt(str); + } + catch (NumberFormatException e) + { + ; // Do nothing; val is the default. + } + return val; + } + + public long getHeaderFieldDate(String name, long val) + { + String str = getHeaderField(name); + if (str != null) + { + Date date; + if ((date = dateFormat1.parse(str, new ParsePosition(0))) != null) + val = date.getTime(); + else if ((date = dateFormat2.parse(str, new ParsePosition(0))) != null) + val = date.getTime(); + else if ((date = dateFormat3.parse(str, new ParsePosition(0))) != null) + val = date.getTime(); + } + return val; + } + + public String getHeaderFieldKey(int n) + { + // Subclasses for specific protocols override this. + return null; + } + + public Object getContent() throws IOException + { + // FIXME: Doc indicates that other criteria should be applied as + // heuristics to determine the true content type, e.g. see + // guessContentTypeFromName() and guessContentTypeFromStream methods + // as well as FileNameMap class & fileNameMap field & get/set methods. + String cType = getContentType(); + contentHandler = setContentHandler(cType); + if (contentHandler == null) + return getInputStream(); + + return contentHandler.getContent(this); + } + +// TODO12: public Permission getPermission() throws IOException +// { +// // Subclasses may override this. +// return java.security.AllPermission; +// } + + public InputStream getInputStream() throws IOException + { + // Subclasses for specific protocols override this. + throw new UnknownServiceException("Protocol " + url.getProtocol() + + " does not support input."); + } + + public OutputStream getOutputStream() throws IOException + { + // Subclasses for specific protocols override this. + throw new UnknownServiceException("Protocol " + url.getProtocol() + + " does not support output."); + } + + public String toString() + { + return this.getClass().getName() + ":" + url.toString(); + } + + public void setDoInput(boolean doinput) + { + if (connected) + throw new IllegalAccessError("Already connected"); + + doInput = doinput; + } + + public boolean getDoInput() + { + return doInput; + } + + public void setDoOutput(boolean dooutput) + { + if (connected) + throw new IllegalAccessError("Already connected"); + + doOutput = dooutput; + if (doOutput) + doInput = false; + } + + public boolean getDoOutput() + { + return doOutput; + } + + public void setAllowUserInteraction(boolean allowuserinteraction) + { + if (connected) + throw new IllegalAccessError("Already connected"); + + allowUserInteraction = allowuserinteraction; + } + + public boolean getAllowUserInteraction() + { + return allowUserInteraction; + } + + public static void + setDefaultAllowUserInteraction(boolean defaultallowuserinteraction) + { + defaultAllowUserInteraction = defaultallowuserinteraction; + } + + public static boolean getDefaultAllowUserInteraction() + { + return defaultAllowUserInteraction; + } + + public void setUseCaches(boolean usecaches) + { + if (connected) + throw new IllegalAccessError("Already connected"); + + useCaches = usecaches; + } + + public boolean getUseCaches() + { + return useCaches; + } + + public void setIfModifiedSince(long ifmodifiedsince) + { + if (connected) + throw new IllegalAccessError("Already connected"); + + ifModifiedSince = ifmodifiedsince; + } + + public long getIfModifiedSince() + { + return ifModifiedSince; + } + + public boolean getDefaultUseCaches() + { + return defaultUseCaches; + } + + public void setDefaultUseCaches(boolean defaultusecaches) + { + defaultUseCaches = defaultusecaches; + } + + public void setRequestProperty(String key, String value) + { + // Do nothing unless overridden by subclasses that support setting + // header fields in the request. + } + + public String getRequestProperty(String key) + { + // Overridden by subclasses that support reading header fields from the + // request. + return null; + } + + public static void setDefaultRequestProperty(String key, String value) + { + // Do nothing unless overridden by subclasses that support setting + // default request properties. + } + + public static String getDefaultRequestProperty(String key) + { + // Overridden by subclasses that support default request properties. + return null; + } + + public static void setContentHandlerFactory(ContentHandlerFactory fac) + { + if (factory != null) + throw new Error("ContentHandlerFactory already set"); + + // Throw an exception if an extant security mgr precludes + // setting the factory. + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkSetFactory(); + factory = fac; + } + +// TODO: protected static String guessContentTypeFromName(String fname) +// { +// } + +// TODO: public static String guessContentTypeFromStream(InputStream is) +// throws IOException +// { +// } + +// TODO12: protected void parseURL(URL u, String spec, int start, int limit) + + // JDK1.2 + public static FileNameMap getFileNameMap() + { + return fileNameMap; + } + + // JDK1.2 + public static void setFileNameMap(FileNameMap map) + { + // Throw an exception if an extant security mgr precludes + // setting the factory. + SecurityManager s = System.getSecurityManager(); + if (s != null) + s.checkSetFactory(); + + fileNameMap = map; + } + + private ContentHandler setContentHandler(String contentType) + { + ContentHandler handler; + + // No content type so just handle it as the default. + if (contentType == null || contentType == "") + return null; + + // See if a handler has been cached for this content type. + // For efficiency, if a content type has been searched for but not + // found, it will be in the hash table but as the contentType String + // instead of a ContentHandler. + if ((handler = (ContentHandler) handlers.get(contentType)) != null) + if (handler instanceof ContentHandler) + return handler; + else + return null; + + // If a non-default factory has been set, use it to find the content type. + if (factory != null) + handler = factory.createContentHandler(contentType); + + // Non-default factory may have returned null or a factory wasn't set. + // Use the default search algorithm to find a handler for this content type. + if (handler == null) + { + // Get the list of packages to check and append our default handler + // to it, along with the JDK specified default as a last resort. + // Except in very unusual environments the JDK specified one shouldn't + // ever be needed (or available). + String propVal = System.getProperty("java.content.handler.pkgs"); + propVal = (propVal == null) ? "" : (propVal + "|"); + propVal = propVal + "gnu.gcj.content|sun.net.www.content"; + + // Replace the '/' character in the content type with '.' and + // all other non-alphabetic, non-numeric characters with '_'. + StringTokenizer pkgPrefix = new StringTokenizer(propVal, "|"); + char[] cArray = contentType.toCharArray(); + for (int i = 0; i < cArray.length; i++) + { + if (cArray[i] == '/') + cArray[i] = '.'; + else if (! ((cArray[i] >= 'A' && cArray[i] <= 'Z') || + (cArray[i] >= 'a' && cArray[i] <= 'z') || + (cArray[i] >= '0' && cArray[i] <= '9'))) + cArray[i] = '_'; + } + String contentClass = new String(cArray); + + // See if a class of this content type exists in any of the packages. + do + { + String facName = pkgPrefix.nextToken() + "." + contentClass; + try + { + handler = + (ContentHandler) Class.forName(facName).newInstance(); + } + catch (Exception e) + { + // Can't instantiate; handler still null, go on to next element. + } + } while ((handler == null || + ! (handler instanceof ContentHandler)) && + pkgPrefix.hasMoreTokens()); + } + + // Update the hashtable with the new content handler. + if (handler != null && handler instanceof ContentHandler) + { + handlers.put(contentType, handler); + return handler; + } + + // For efficiency on subsequent searches, put a dummy entry in the hash + // table for content types that don't have a non-default ContentHandler. + handlers.put(contentType, contentType); + return null; + } +} diff --git a/libjava/java/net/URLStreamHandler.java b/libjava/java/net/URLStreamHandler.java new file mode 100644 index 00000000000..29e0e6d4137 --- /dev/null +++ b/libjava/java/net/URLStreamHandler.java @@ -0,0 +1,107 @@ +// URLStreamHandler.java - Superclass of all stream protocol handlers. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 4, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public abstract class URLStreamHandler +{ + protected abstract URLConnection openConnection(URL u) + throws java.io.IOException; + +protected void parseURL(URL u, String spec, int start, int limit) + { + String tmpStr; + String host = ""; // Initialize to null string. + String file; + int port = -1; + int colon; + + /* TBD: The JDK 1.2 doc specifically says that limit is the position + * to stop parsing at and that it will be either the end of the string + * or the position of '#'; thus the doc infers that this method does + * not set the ref. + */ + tmpStr = spec.substring(start, limit); + int hostEnd = 0; + if (tmpStr.startsWith("//")) + { + int slash = tmpStr.indexOf('/', 2); + hostEnd = tmpStr.length(); + if (slash >= 0) + hostEnd = slash; + + host = tmpStr.substring(2, hostEnd); + + // Look for optional port number. + if ((colon = host.indexOf(':')) >= 0) + { + try + { + port = Integer.parseInt(host.substring(colon + 1)); + } + catch (NumberFormatException e) + { + ; // Ignore invalid port values; port is already set to -1. + } + host = host.substring(0, colon); + } + } + + if (hostEnd < tmpStr.length()) + file = ((tmpStr.startsWith("/")) ? "" : "/") + tmpStr.substring(hostEnd); + else + file = "/"; + + u.set(u.getProtocol(), host, port, file, u.getRef()); + } + + protected void setURL(URL u, String protocol, String host, int port, + String file, String ref) + { + u.set(protocol, host, port, file, ref); + } + + protected String toExternalForm(URL u) + { + String resStr, host, file, ref; + int port; + + resStr = u.getProtocol() + ":"; + host = u.getHost(); + port = u.getPort(); + file = u.getFile(); + ref = u.getRef(); + + if (! host.equals("")) + { + resStr = resStr + "//" + host; + if (port >= 0) + resStr = resStr + ":" + port; + } + + resStr = resStr + file; + + if (ref != null) + resStr = resStr + "#" + ref; + + return resStr; + } +} diff --git a/libjava/java/net/URLStreamHandlerFactory.java b/libjava/java/net/URLStreamHandlerFactory.java new file mode 100644 index 00000000000..474d723d4f5 --- /dev/null +++ b/libjava/java/net/URLStreamHandlerFactory.java @@ -0,0 +1,27 @@ +// URLStreamHandlerFactory.java - Abstract URL Stream Handler factory. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public abstract interface URLStreamHandlerFactory +{ + public URLStreamHandler createURLStreamHandler(String protocol); +} diff --git a/libjava/java/net/UnknownHostException.java b/libjava/java/net/UnknownHostException.java new file mode 100644 index 00000000000..1c2050923e9 --- /dev/null +++ b/libjava/java/net/UnknownHostException.java @@ -0,0 +1,34 @@ +// UnknownHostException.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Per Bothner + * @date January 6, 1999. + */ + +/* + * Written using on-line Java Platform 1.2 API Specification. + * Status: Believed complete and correct. + */ + +public class UnknownHostException extends java.io.IOException +{ + public UnknownHostException () + { + super(); + } + + public UnknownHostException (String host) + { + super(host); + } +} diff --git a/libjava/java/net/UnknownServiceException.java b/libjava/java/net/UnknownServiceException.java new file mode 100644 index 00000000000..dba798e0e80 --- /dev/null +++ b/libjava/java/net/UnknownServiceException.java @@ -0,0 +1,35 @@ +// UnknownServiceException.java + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.net; + +/** + * @author Warren Levy + * @date March 5, 1999. + */ + +/** + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public class UnknownServiceException extends java.io.IOException +{ + public UnknownServiceException() + { + super(); + } + + public UnknownServiceException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/net/natInetAddress.cc b/libjava/java/net/natInetAddress.cc new file mode 100644 index 00000000000..7f7d953b9c1 --- /dev/null +++ b/libjava/java/net/natInetAddress.cc @@ -0,0 +1,270 @@ +// natClass.cc - Implementation of java.lang.Class native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#ifdef HAVE_UNISTD_H +#include +#endif +#include +#include + +#include +#include +#ifdef HAVE_SYS_SOCKET_H +#include +#endif +#ifdef HAVE_NETINET_IN_H +#include +#endif +#ifdef HAVE_ARPA_INET_H +#include +#endif +#ifdef HAVE_NETDB_H +#include +#endif + +#include +#include +#include +#include +#include + +#if defined(HAVE_UNAME) && ! defined(HAVE_GETHOSTNAME) +#include +#endif + +#ifndef HAVE_GETHOSTNAME_DECL +extern "C" int gethostname (char *name, int namelen); +#endif + +jbyteArray +java::net::InetAddress::aton (jstring host) +{ + char *hostname; + char buf[100]; + int len = JvGetStringUTFLength(host); + if (len < 100) + hostname = buf; + else + hostname = (char*) _Jv_AllocBytesChecked (len+1); + JvGetStringUTFRegion (host, 0, host->length(), hostname); + buf[len] = '\0'; + char* bytes = NULL; + int blen = 0; +#ifdef HAVE_INET_ATON + struct in_addr laddr; + if (inet_aton (hostname, &laddr)) + { + bytes = (char*) &laddr; + len = 4; + } +#elif defined(HAVE_INET_ADDR) + in_addr_t laddr = inet_addr (hostname); + if (laddr != (in_addr_t)(-1)) + { + bytes = (char*) &laddr; + len = 4; + } +#endif +#ifdef HAVE_INET_PTON + char inet6_addr[16]; + if (len == 0 && inet_pton (AF_INET6, hostname, inet6_addr) > 0) + { + bytes = inet6_addr; + len = 16; + } +#endif + if (blen == 0) + return NULL; + jbyteArray result = JvNewByteArray (len); + memcpy (elements (result), bytes, blen); + return result; +} + + +JArray * +java::net::InetAddress::lookup (jstring host, java::net::InetAddress* iaddr, + jboolean all) +{ + struct hostent *hptr = NULL; +#if defined (HAVE_GETHOSTBYNAME_R) || defined (HAVE_GETHOSTBYADDR_R) + struct hostent hent_r; + char fixed_buffer[200]; + char *buffer_r = fixed_buffer; + int size_r = sizeof (fixed_buffer); +#endif + + if (host != NULL) + { + char *hostname; + char buf[100]; + int len = JvGetStringUTFLength(host); + if (len < 100) + hostname = buf; + else + hostname = (char*) _Jv_AllocBytesChecked (len+1); + JvGetStringUTFRegion (host, 0, host->length(), hostname); + buf[len] = '\0'; +#ifdef HAVE_GETHOSTBYNAME_R + int herr = ERANGE; + while (hptr == NULL && herr == ERANGE) + { + int ok; +#ifdef GETHOSTBYNAME_R_RETURNS_INT + ok = ! gethostbyname_r (hostname, &hent_r, buffer_r, size_r, + &hptr, &herr); +#else + hptr = gethostbyname_r (hostname, &hent_r, buffer_r, size_r, &herr); + ok = hptr != NULL; +#endif /* GETHOSTNAME_R_RETURNS_INT */ + if (! ok && herr == ERANGE) + { + size_r *= 2; + buffer_r = (char *) _Jv_AllocBytesChecked (size_r); + } + } +#else + // FIXME: this is insufficient if some other piece of code calls + // this gethostbyname. + JvSynchronize sync (java::net::InetAddress::localhostAddress); + hptr = gethostbyname (hostname); +#endif /* HAVE_GETHOSTBYNAME_R */ + } + else + { + jbyteArray bytes = iaddr->address; + char *chars = (char*) elements (bytes); + int len = bytes->length; + int type; + char *val; + if (len == 4) + { + val = chars; + type = AF_INET; + } +#ifdef HAVE_INET6 + else if (len == 16) + { + val = (char *) &chars; + type = AF_INET16; + } +#endif /* HAVE_INET6 */ + else + JvFail ("unrecognized size"); + +#ifdef HAVE_GETHOSTBYADDR_R + int herr = ERANGE; + while (hptr == NULL && herr == ERANGE) + { + int ok; +#ifdef GETHOSTBYADDR_R_RETURNS_INT + ok = ! gethostbyaddr_r (val, len, type, &hent_r, + buffer_r, size_r, &hptr, &herr); +#else + hptr = gethostbyaddr_r (val, len, type, &hent_r, + buffer_r, size_r, &herr); + ok = hptr != NULL; +#endif /* GETHOSTBYADDR_R_RETURNS_INT */ + if (! ok && herr == ERANGE) + { + size_r *= 2; + buffer_r = (char *) _Jv_AllocBytesChecked (size_r); + } + } +#else /* HAVE_GETHOSTBYADDR_R */ + // FIXME: this is insufficient if some other piece of code calls + // this gethostbyaddr. + JvSynchronize sync (java::net::InetAddress::localhostAddress); + hptr = gethostbyaddr (val, len, type); +#endif /* HAVE_GETHOSTBYADDR_R */ + } + if (hptr != NULL) + { + host = JvNewStringUTF (hptr->h_name); + java::lang::SecurityException *ex = checkConnect (host); + if (ex != NULL) + { + if (iaddr == NULL || iaddr->address == NULL) + JvThrow (ex); + hptr = NULL; + } + } + if (hptr == NULL) + { + if (iaddr != NULL && iaddr->address != NULL) + { + iaddr->hostname = iaddr->getHostAddress(); + return NULL; + } + else + JvThrow (new java::net::UnknownHostException(host)); + } + int count; + if (all) + { + char** ptr = hptr->h_addr_list; + count = 0; + while (*ptr++) count++; + } + else + count = 1; + JArray *result; + java::net::InetAddress** iaddrs; + if (all) + { + result = java::net::InetAddress::allocArray (count); + iaddrs = elements (result); + } + else + { + result = NULL; + iaddrs = &iaddr; + } + + for (int i = 0; i < count; i++) + { + if (iaddrs[i] == NULL) + iaddrs[i] = new java::net::InetAddress (NULL, NULL); + if (i == 0) + iaddrs[0]->hostname = host; + if (iaddrs[i]->address == NULL) + { + char *bytes = hptr->h_addr_list[i]; + iaddr->address = JvNewByteArray (hptr->h_length); + memcpy (elements (iaddr->address), bytes, hptr->h_length); + } + } + return result; +} + +jstring +java::net::InetAddress::getLocalHostname () +{ + char *chars; +#ifdef HAVE_GETHOSTNAME + char buffer[MAXHOSTNAMELEN]; + if (gethostname (buffer, MAXHOSTNAMELEN)) + return NULL; + chars = buffer; +#elif HAVE_UNAME + struct utsname stuff; + if (uname (&stuff) != 0) + return NULL: + chars = stuff.nodename; +#else + return NULL; +#endif + // It is admittedly non-optimal to convert the hostname to Unicode + // only to convert it back in getByName, but simplicity wins. Note + // that unless there is a SecurityManager, we only get called once + // anyway, thanks to the InetAddress.localhost cache. + return JvNewStringUTF (chars); +} diff --git a/libjava/java/net/natPlainSocketImpl.cc b/libjava/java/net/natPlainSocketImpl.cc new file mode 100644 index 00000000000..076ee711948 --- /dev/null +++ b/libjava/java/net/natPlainSocketImpl.cc @@ -0,0 +1,177 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#ifndef HAVE_SOCKLEN_T +typedef int socklen_t; +#endif + +union SockAddr +{ + struct sockaddr_in address; +#ifdef HAVE_INET6 + struct sockaddr_in6 address6; +#endif +}; + +void +java::net::PlainSocketImpl::create (jboolean stream) +{ + int sock = ::socket (AF_INET, stream ? SOCK_STREAM : SOCK_DGRAM, 0); + if (sock < 0) + { + char msg[100]; + char* strerr = strerror (errno); + sprintf (msg, "SocketImpl.create: %.*s", 80, strerr); + JvThrow (new java::io::IOException (JvNewStringUTF (msg))); + } + fnum = sock; + fd = new java::io::FileDescriptor (sock); +} + +void +java::net::PlainSocketImpl::bind (java::net::InetAddress *host, jint lport) +{ + union SockAddr u; + jbyteArray haddress = host->address; + jbyte *bytes = elements (haddress); + int len = haddress->length; + struct sockaddr *ptr = (struct sockaddr *) &u.address; + if (len == 4) + { + u.address.sin_family = AF_INET; + memcpy (&u.address.sin_addr, bytes, len); + len = sizeof (struct sockaddr_in); + u.address.sin_port = htons (lport); + } +#ifdef HAVE_INET6 + else if (len == 16) + { + u.address6.sin6_family = AF_INET6; + memcpy (&u.address6.sin6_addr, bytes, len); + len = sizeof (struct sockaddr_in6); + u.address6.sin6_port = htons (lport); + } +#endif + else + goto error; + if (::bind (fnum, ptr, len) == 0) + { + address = host; + localport = lport; + return; + } + error: + char msg[100]; + char* strerr = strerror (errno); + sprintf (msg, "SocketImpl.bind: %.*s", 80, strerr); + JvThrow (new java::io::IOException (JvNewStringUTF (msg))); +} + +void +java::net::PlainSocketImpl::connect (java::net::InetAddress *host, jint rport) +{ + union SockAddr u; + jbyteArray haddress = host->address; + jbyte *bytes = elements (haddress); + int len = haddress->length; + struct sockaddr *ptr = (struct sockaddr *) &u.address; + if (len == 4) + { + u.address.sin_family = AF_INET; + memcpy (&u.address.sin_addr, bytes, len); + len = sizeof (struct sockaddr_in); + u.address.sin_port = htons (rport); + } +#ifdef HAVE_INET6 + else if (len == 16) + { + u.address6.sin6_family = AF_INET6; + memcpy (&u.address6.sin6_addr, bytes, len); + len = sizeof (struct sockaddr_in6); + u.address6.sin6_port = htons (rport); + } +#endif + else + goto error; + if (::connect (fnum, ptr, len) == 0) + { + address = host; + port = rport; + return; + } + error: + char msg[100]; + char* strerr = strerror (errno); + sprintf (msg, "SocketImpl.connect: %.*s", 80, strerr); + JvThrow (new java::io::IOException (JvNewStringUTF (msg))); +} + +void +java::net::PlainSocketImpl::listen (jint backlog) +{ + if (::listen (fnum, backlog) != 0) + { + char msg[100]; + char* strerr = strerror (errno); + sprintf (msg, "SocketImpl.listen: %.*s", 80, strerr); + JvThrow (new java::io::IOException (JvNewStringUTF (msg))); + } +} + +void +java::net::PlainSocketImpl::accept (java::net::PlainSocketImpl *s) +{ + union SockAddr u; + socklen_t addrlen = sizeof(u); + int new_socket = ::accept (fnum, (sockaddr*) &u, &addrlen); + if (new_socket < 0) + goto error; + jbyteArray raddr; + jint rport; + if (u.address.sin_family == AF_INET) + { + raddr = JvNewByteArray (4); + memcpy (elements (raddr), &u.address.sin_addr, 4); + rport = ntohs (u.address.sin_port); + } +#ifdef HAVE_INET6 + { + raddr = JvNewByteArray (16); + memcpy (elements (raddr), &u.address6.sin6_addr, 16); + rport = ntohs (u.address6.sin6_port); + } +#endif + else + goto error; + s->fnum = new_socket; + s->localport = localport; + s->address = new InetAddress (raddr, NULL); + s->port = rport; + s->fd = new java::io::FileDescriptor (new_socket); + return; + error: + char msg[100]; + char* strerr = strerror (errno); + sprintf (msg, "SocketImpl.accept: %.*s", 80, strerr); + JvThrow (new java::io::IOException (JvNewStringUTF (msg))); +} diff --git a/libjava/java/text/BreakIterator.java b/libjava/java/text/BreakIterator.java new file mode 100644 index 00000000000..0e09d456679 --- /dev/null +++ b/libjava/java/text/BreakIterator.java @@ -0,0 +1,160 @@ +// BreakIterator.java - Iterate over logical breaks in text. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.io.Serializable; +import java.util.Locale; +import java.util.MissingResourceException; +import java.util.ResourceBundle; + +/** + * @author Tom Tromey + * @date March 19, 1999 + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct to 1.1. + */ + +public abstract class BreakIterator implements Cloneable, Serializable +{ + // The value was discovered by writing a test program. + public static final int DONE = -1; + + protected BreakIterator () + { + } + + public abstract int current (); + public abstract int first (); + public abstract int following (int pos); + + public static synchronized Locale[] getAvailableLocales () + { + // FIXME. + return null; + } + + private static BreakIterator getInstance (String type, Locale loc) + { + String className; + try + { + ResourceBundle res + = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc); + className = res.getString(type); + } + catch (MissingResourceException x) + { + return null; + } + try + { + Class k = Class.forName(className); + return (BreakIterator) k.newInstance(); + } + catch (ClassNotFoundException x1) + { + return null; + } + catch (InstantiationException x2) + { + return null; + } + catch (IllegalAccessException x3) + { + return null; + } + } + + public static BreakIterator getCharacterInstance () + { + return getCharacterInstance (Locale.getDefault()); + } + + public static BreakIterator getCharacterInstance (Locale loc) + { + BreakIterator r = getInstance ("CharacterIterator", loc); + if (r == null) + r = new gnu.gcj.text.CharacterBreakIterator (); + return r; + } + + public static BreakIterator getLineInstance () + { + return getLineInstance (Locale.getDefault()); + } + + public static BreakIterator getLineInstance (Locale loc) + { + BreakIterator r = getInstance ("LineIterator", loc); + if (r == null) + r = new gnu.gcj.text.LineBreakIterator (); + return r; + } + + public static BreakIterator getSentenceInstance () + { + return getSentenceInstance (Locale.getDefault()); + } + + public static BreakIterator getSentenceInstance (Locale loc) + { + BreakIterator r = getInstance ("SentenceIterator", loc); + if (r == null) + r = new gnu.gcj.text.SentenceBreakIterator (); + return r; + } + + public abstract CharacterIterator getText (); + + public static BreakIterator getWordInstance () + { + return getWordInstance (Locale.getDefault()); + } + + public static BreakIterator getWordInstance (Locale loc) + { + BreakIterator r = getInstance ("WordIterator", loc); + if (r == null) + r = new gnu.gcj.text.WordBreakIterator (); + return r; + } + + public boolean isBoundary (int pos) + { + if (pos == 0) + return true; + return following (pos - 1) == pos; + } + + public abstract int last (); + public abstract int next (); + public abstract int next (int n); + + public int preceding (int pos) + { + if (following (pos) == DONE) + last (); + while (previous () >= pos) + ; + return current (); + } + + public abstract int previous (); + + public void setText (String newText) + { + setText (new StringCharacterIterator (newText)); + } + + public abstract void setText (CharacterIterator newText); +} diff --git a/libjava/java/text/CharacterIterator.java b/libjava/java/text/CharacterIterator.java new file mode 100644 index 00000000000..d34e988a154 --- /dev/null +++ b/libjava/java/text/CharacterIterator.java @@ -0,0 +1,36 @@ +// CharacterIterator.java - Protocol for iterating over Unicode characters. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +/** + * @author Tom Tromey + * @date February 22, 1999 + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct to 1.1. + */ + +public interface CharacterIterator extends Cloneable +{ + public abstract Object clone (); + public abstract char current (); + public abstract char first (); + public abstract int getBeginIndex (); + public abstract int getEndIndex (); + public abstract int getIndex (); + public abstract char last (); + public abstract char next (); + public abstract char previous (); + public abstract char setIndex (int idx); + + public static final char DONE = '\uffff'; +} diff --git a/libjava/java/text/ChoiceFormat.java b/libjava/java/text/ChoiceFormat.java new file mode 100644 index 00000000000..bed62a75e53 --- /dev/null +++ b/libjava/java/text/ChoiceFormat.java @@ -0,0 +1,310 @@ +// ChoiceFormat.java - Formatter for `switch'-like string substitution. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.util.Vector; + +/** + * @author Tom Tromey + * @date March 9, 1999 + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 from http://www.javasoft.com. + * Status: Believed complete and correct to 1.1. + */ + +public class ChoiceFormat extends NumberFormat +{ + // Note: we assume the same kind of quoting rules apply here. + // This isn't explicitly documented. But for instance we accept + // '#' as a literal hash in a format string. + public void applyPattern (String newPattern) + { + int index = 0, max = newPattern.length(); + Vector stringVec = new Vector (); + Vector limitVec = new Vector (); + StringBuffer buf = new StringBuffer (); + + while (true) + { + // Find end of double. + int dstart = index; + while (index < max) + { + char c = newPattern.charAt(index); + if (c == '#' || c == '\u2064' || c == '<') + break; + ++index; + } + + if (index == max) + throw new IllegalArgumentException ("unexpected end of text"); + Double d = new Double (newPattern.substring(dstart, index)); + + if (newPattern.charAt(index) == '<') + d = new Double (nextDouble (d.doubleValue())); + + limitVec.addElement(d); + + // Scan text. + ++index; + buf.setLength(0); + while (index < max) + { + char c = newPattern.charAt(index); + if (c == '\'' && index < max + 1 + && newPattern.charAt(index + 1) == '\'') + { + buf.append(c); + ++index; + } + else if (c == '\'' && index < max + 2) + { + buf.append(newPattern.charAt(index + 1)); + index += 2; + } + else if (c == '|') + break; + else + buf.append(c); + ++index; + } + + stringVec.addElement(buf.toString()); + if (index == max) + break; + ++index; + } + + strings = new String[stringVec.size()]; + stringVec.copyInto(strings); + + limits = new double[limitVec.size()]; + for (int i = 0; i < limits.length; ++i) + { + Double d = (Double) limitVec.elementAt(i); + limits[i] = d.doubleValue(); + } + } + + public ChoiceFormat (String newPattern) + { + super (); + applyPattern (newPattern); + } + + public ChoiceFormat (double[] limits, String[] strings) + { + super (); + setChoices (limits, strings); + } + + public Object clone () + { + return new ChoiceFormat (limits, strings); + } + + public boolean equals (Object obj) + { + if (! (obj instanceof ChoiceFormat)) + return false; + ChoiceFormat cf = (ChoiceFormat) obj; + if (limits.length != cf.limits.length) + return false; + for (int i = limits.length - 1; i >= 0; --i) + { + if (limits[i] != cf.limits[i] + || !strings[i].equals(cf.strings[i])) + return false; + } + return true; + } + + public StringBuffer format (long num, StringBuffer appendBuf, + FieldPosition pos) + { + return format ((double) num, appendBuf, pos); + } + + public StringBuffer format (double num, StringBuffer appendBuf, + FieldPosition pos) + { + if (limits.length == 0) + return appendBuf; + + int index = 0; + if (! Double.isNaN(num) && num >= limits[0]) + { + for (; index < limits.length - 1; ++index) + { + if (limits[index] <= num + && index != limits.length - 2 + && num < limits[index + 1]) + break; + } + } + + return appendBuf.append(strings[index]); + } + + public Object[] getFormats () + { + return (Object[]) strings.clone(); + } + + public double[] getLimits () + { + return (double[]) limits.clone(); + } + + public int hashCode () + { + int hash = 0; + for (int i = 0; i < limits.length; ++i) + { + long v = Double.doubleToLongBits(limits[i]); + hash ^= (v ^ (v >>> 32)); + hash ^= strings[i].hashCode(); + } + return hash; + } + + public static final double nextDouble (double d) + { + return nextDouble (d, true); + } + + public static final double nextDouble (double d, boolean next) + { + if (Double.isInfinite(d) || Double.isNaN(d)) + return d; + + long bits = Double.doubleToLongBits(d); + + long mantMask = (1L << mantissaBits) - 1; + long mantissa = bits & mantMask; + + long expMask = (1L << exponentBits) - 1; + long exponent = (bits >>> mantissaBits) & expMask; + + if (next ^ (bits < 0)) // Increment magnitude + { + if (mantissa == (1L << mantissaBits) - 1) + { + mantissa = 0L; + exponent++; + + // Check for absolute overflow. + if (exponent >= (1L << mantissaBits)) + return (bits > 0) ? Double.POSITIVE_INFINITY + : Double.NEGATIVE_INFINITY; + } + else + mantissa++; + } + else // Decrement magnitude + { + if (exponent == 0L && mantissa == 0L) + { + // The only case where there is a change of sign + return next ? Double.MIN_VALUE : -Double.MIN_VALUE; + } + else + { + if (mantissa == 0L) + { + mantissa = (1L << mantissaBits) - 1; + exponent--; + } + else + mantissa--; + } + } + + long result = bits < 0 ? 1 : 0; + result = (result << exponentBits) | exponent; + result = (result << mantissaBits) | mantissa; + return Double.longBitsToDouble(result); + } + + public Number parse (String sourceStr, ParsePosition pos) + { + int index = pos.getIndex(); + for (int i = 0; i < limits.length; ++i) + { + if (sourceStr.startsWith(strings[i], index)) + { + pos.setIndex(index + strings[i].length()); + return new Double (limits[i]); + } + } + pos.setErrorIndex(index); + return new Double (Double.NaN); + } + + public static final double previousDouble (double d) + { + return nextDouble (d, false); + } + + public void setChoices (double[] limits, String[] strings) + { + if (limits == null || strings == null) + throw new NullPointerException (); + if (limits.length != strings.length) + throw new IllegalArgumentException (); + this.strings = (String[]) strings.clone(); + this.limits = (double[]) limits.clone(); + } + + private final void quoteString (StringBuffer dest, String text) + { + int max = text.length(); + for (int i = 0; i < max; ++i) + { + char c = text.charAt(i); + if (c == '\'') + { + dest.append(c); + dest.append(c); + } + else if (c == '#' || c == '|' || c == '\u2064' || c == '<') + { + dest.append('\''); + dest.append(c); + dest.append('\''); + } + else + dest.append(c); + } + } + + public String toPattern () + { + StringBuffer result = new StringBuffer (); + for (int i = 0; i < limits.length; ++i) + { + result.append(limits[i]); + result.append('#'); + quoteString (result, strings[i]); + } + return result.toString(); + } + + // Formats and limits. + private String[] strings; + private double[] limits; + + // Number of mantissa bits in double. + private static final int mantissaBits = 52; + // Number of exponent bits in a double. + private static final int exponentBits = 11; +} diff --git a/libjava/java/text/DateFormat.java b/libjava/java/text/DateFormat.java new file mode 100644 index 00000000000..bfd6b01a777 --- /dev/null +++ b/libjava/java/text/DateFormat.java @@ -0,0 +1,301 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.util.*; + +/** + * @author Per Bothner + * @date October 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Mostly complete; search for FIXME to see omissions. + */ + +public abstract class DateFormat extends Format implements Cloneable +{ + protected Calendar calendar; + protected NumberFormat numberFormat; + + // (Values determined using a test program.) + public final static int FULL = 0; + public final static int LONG = 1; + public final static int MEDIUM = 2; + public final static int SHORT = 3; + public final static int DEFAULT = MEDIUM; + + public final static int ERA_FIELD = 0; + public final static int YEAR_FIELD = 1; + public final static int MONTH_FIELD = 2; + public final static int DATE_FIELD = 3; + public final static int HOUR_OF_DAY1_FIELD = 4; + public final static int HOUR_OF_DAY0_FIELD = 5; + public final static int MINUTE_FIELD = 6; + public final static int SECOND_FIELD = 7; + public final static int MILLISECOND_FIELD = 8; + public final static int DAY_OF_WEEK_FIELD = 9; + public final static int DAY_OF_YEAR_FIELD = 10; + public final static int DAY_OF_WEEK_IN_MONTH_FIELD = 11; + public final static int WEEK_OF_YEAR_FIELD = 12; + public final static int WEEK_OF_MONTH_FIELD = 13; + public final static int AM_PM_FIELD = 14; + public final static int HOUR1_FIELD = 15; + public final static int HOUR0_FIELD = 16; + public final static int TIMEZONE_FIELD = 17; + + protected DateFormat () + { + } + + public boolean equals (Object obj) + { + if (! (obj instanceof DateFormat)) + return false; + DateFormat d = (DateFormat) obj; + return calendar.equals(d.calendar) && numberFormat.equals(d.numberFormat); + } + + public final StringBuffer format (Object obj, + StringBuffer buf, FieldPosition pos) + { + if (obj instanceof Number) + return format (new Date(((Number) obj).longValue()), buf, pos); + return format ((Date) obj, buf, pos); + } + + public final String format (Date date) + { + StringBuffer sb = new StringBuffer (); + format (date, sb, new FieldPosition (MONTH_FIELD)); + return sb.toString(); + } + + public abstract StringBuffer format (Date date, + StringBuffer buf, FieldPosition pos); + + public static Locale[] getAvailableLocales () + { + return null; // FIXME + } + + public Calendar getCalendar () + { + return calendar; + } + + private static final DateFormat computeInstance (int style, Locale loc, + boolean use_date, + boolean use_time) + { + ResourceBundle res; + try + { + res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc); + } + catch (MissingResourceException x) + { + res = null; + } + + String pattern = null; + if (use_date) + { + String name, def; + switch (style) + { + case FULL: + name = "fullDateFormat"; + def = "EEEE MMMM d, yyyy G"; + break; + case LONG: + name = "longDateFormat"; + def = "MMMM d, yyyy"; + break; + case MEDIUM: + name = "mediumDateFormat"; + def = "d-MMM-yy"; + break; + case SHORT: + name = "shortDateFormat"; + def = "M/d/yy"; + break; + default: + throw new IllegalArgumentException (); + } + try + { + pattern = res == null ? def : res.getString(name); + } + catch (MissingResourceException x) + { + pattern = def; + } + } + + if (use_time) + { + if (pattern == null) + pattern = ""; + else + pattern += " "; + + String name, def; + switch (style) + { + case FULL: + name = "fullTimeFormat"; + def = "h:mm:ss;S 'o''clock' a z"; + break; + case LONG: + name = "longTimeFormat"; + def = "h:mm:ss a z"; + break; + case MEDIUM: + name = "mediumTimeFormat"; + def = "h:mm:ss a"; + break; + case SHORT: + name = "shortTimeFormat"; + def = "h:mm a"; + break; + default: + throw new IllegalArgumentException (); + } + + String s; + try + { + s = res == null ? def : res.getString(name); + } + catch (MissingResourceException x) + { + s = def; + } + pattern += s; + } + + return new SimpleDateFormat (pattern, loc); + } + + public static final DateFormat getDateInstance () + { + return getDateInstance (DEFAULT, Locale.getDefault()); + } + + public static final DateFormat getDateInstance (int style) + { + return getDateInstance (style, Locale.getDefault()); + } + + public static final DateFormat getDateInstance (int style, Locale loc) + { + return computeInstance (style, loc, true, false); + } + + public static final DateFormat getDateTimeInstance () + { + return getDateTimeInstance (DEFAULT, Locale.getDefault()); + } + + public static final DateFormat getDateTimeInstance (int style) + { + return getDateTimeInstance (style, Locale.getDefault()); + } + + public static final DateFormat getDateTimeInstance (int style, Locale loc) + { + return computeInstance (style, loc, true, true); + } + + public static final DateFormat getInstance () + { + // JCL book says SHORT. + return getDateTimeInstance (SHORT, Locale.getDefault()); + } + + public NumberFormat getNumberFormat () + { + return numberFormat; + } + + public static final DateFormat getTimeInstance () + { + return getTimeInstance (DEFAULT, Locale.getDefault()); + } + + public static final DateFormat getTimeInstance (int style) + { + return getTimeInstance (style, Locale.getDefault()); + } + + public static final DateFormat getTimeInstance (int style, Locale loc) + { + return computeInstance (style, loc, false, true); + } + + public TimeZone getTimeZone () + { + return calendar.getTimeZone(); + } + + public int hashCode () + { + int hash = calendar.hashCode(); + if (numberFormat != null) + hash ^= numberFormat.hashCode(); + return hash; + } + + public boolean isLenient () + { + return calendar.isLenient(); + } + + public Date parse (String source) throws ParseException + { + ParsePosition pos = new ParsePosition(0); + Date result = parse (source, pos); + if (result == null) + { + int index = pos.getErrorIndex(); + if (index < 0) + index = pos.getIndex(); + throw new ParseException("invalid Date syntax", index); + } + return result; + } + + public abstract Date parse (String source, ParsePosition pos); + + public Object parseObject (String source, ParsePosition pos) + { + return parse(source, pos); + } + + public void setCalendar (Calendar calendar) + { + this.calendar = calendar; + } + + public void setLenient (boolean lenient) + { + calendar.setLenient(lenient); + } + + public void setNumberFormat (NumberFormat numberFormat) + { + this.numberFormat = numberFormat; + } + + public void setTimeZone (TimeZone timeZone) + { + calendar.setTimeZone(timeZone); + } +} diff --git a/libjava/java/text/DateFormatSymbols.java b/libjava/java/text/DateFormatSymbols.java new file mode 100644 index 00000000000..d21cdeada10 --- /dev/null +++ b/libjava/java/text/DateFormatSymbols.java @@ -0,0 +1,265 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.util.Locale; +import java.util.MissingResourceException; +import java.util.ResourceBundle; + +/** + * @author Per Bothner + * @date October 24, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3. + * Status: Believed complete and correct. + */ + +public class DateFormatSymbols extends Object + implements java.io.Serializable, Cloneable +{ + private String[] ampms; + private String[] eras; + private String localPatternChars; + private String[] months; + private String[] shortMonths; + private String[] shortWeekdays; + private String[] weekdays; + private String[][] zoneStrings; + + private static final String[] ampmsDefault = {"AM", "PM" }; + private static final String[] erasDefault = {"BC", "AD" }; + // localPatternCharsDefault is used by SimpleDateFormat. + protected static final String localPatternCharsDefault + = "GyMdkHmsSEDFwWahKz"; + private static final String[] monthsDefault = { + "January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December", "" + }; + private static final String[] shortMonthsDefault = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "" + }; + private static final String[] shortWeekdaysDefault = { + "", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" + }; + private static final String[] weekdaysDefault = { + "", "Sunday", "Monday", "Tuesday", + "Wednesday", "Thursday", "Friday", "Saturday" + }; + + private static String[][] zoneStringsDefault = { + { "PST", "Pacific Standard Time", "PST", + /**/ "Pacific Daylight Time", "PDT", "San Francisco" }, + { "MST", "Mountain Standard Time", "MST", + /**/ "Mountain Daylight Time", "MDT", "Denver" }, + { "PNT", "Mountain Standard Time", "MST", + /**/ "Mountain Standard Time", "MST", "Phoenix" }, + { "CST", "Central Standard Time", "CST", + /**/ "Central Daylight Time", "CDT", "Chicago" }, + { "EST", "Eastern Standard Time", "EST", + /**/ "Eastern Daylight Time", "EDT", "Boston" }, + { "IET", "Eastern Standard Time", "EST", + /**/ "Eastern Standard Time", "EST", "Indianapolis" }, + { "PRT", "Atlantic Standard Time", "AST", + /**/ "Atlantic Daylight Time", "ADT", "Halifax" }, + { "HST", "Hawaii Standard Time", "HST", + /**/ "Hawaii Daylight Time", "HDT", "Honolulu" }, + { "AST", "Alaska Standard Time", "AST", + /**/ "Alaska Daylight Time", "ADT", "Anchorage" } + }; + + private final Object safeGetResource (ResourceBundle res, + String key, Object def) + { + if (res != null) + { + try + { + return res.getObject(key); + } + catch (MissingResourceException x) + { + } + } + return def; + } + + public DateFormatSymbols (Locale locale) + { + ResourceBundle res; + try + { + res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", locale); + } + catch (MissingResourceException x) + { + res = null; + } + ampms = (String[]) safeGetResource (res, "ampm", ampmsDefault); + eras = (String[]) safeGetResource (res, "eras", erasDefault); + localPatternChars = (String) safeGetResource (res, "datePatternChars", + localPatternCharsDefault); + months = (String[]) safeGetResource (res, "months", monthsDefault); + shortMonths = (String[]) safeGetResource (res, "shortMonths", + shortMonthsDefault); + shortWeekdays = (String[]) safeGetResource (res, "shortWeekdays", + shortWeekdaysDefault); + weekdays = (String[]) safeGetResource (res, "weekdays", weekdaysDefault); + zoneStrings = (String[][]) safeGetResource (res, "zoneStrings", + zoneStringsDefault); + } + + public DateFormatSymbols () + { + this (Locale.getDefault()); + } + + public String[] getAmPmStrings() + { + return ampms; + } + + public String[] getEras() + { + return eras; + } + + + public String getLocalPatternChars() + { + return localPatternChars; + } + + public String[] getMonths () + { + return months; + } + + public String[] getShortMonths () + { + return shortMonths; + } + + public String[] getShortWeekdays () + { + return shortWeekdays; + } + + public String[] getWeekdays () + { + return weekdays; + } + + public String[] [] getZoneStrings () + { + return zoneStrings; + } + + public void setAmPmStrings (String[] value) + { + ampms = value; + } + + public void setEras (String[] value) + { + eras = value; + } + + public void setLocalPatternChars (String value) + { + localPatternChars = value; + } + + public void setMonths (String[] value) + { + months = value; + } + + public void setShortMonths (String[] value) + { + shortMonths = value; + } + + public void setShortWeekdays (String[] value) + { + shortWeekdays = value; + } + + public void setWeekdays (String[] value) + { + weekdays = value; + } + + public void setZoneStrings (String[][] value) + { + zoneStrings = value; + } + + /* Does a "deep" equality test - recurses into arrays. */ + protected static boolean equals (Object x, Object y) + { + if (x == y) + return true; + if (x == null || y == null) + return false; + if (! (x instanceof Object[]) || ! (y instanceof Object[])) + return x.equals(y); + Object[] xa = (Object[]) x; + Object[] ya = (Object[]) y; + if (xa.length != ya.length) + return false; + for (int i = xa.length; --i >= 0; ) + { + if (! equals(xa[i], ya[i])) + return false; + } + return true; + } + + private static int hashCode (Object x) + { + if (x == null) + return 0; + if (! (x instanceof Object[])) + return x.hashCode(); + Object[] xa = (Object[]) x; + int hash = 0; + for (int i = 0; i < xa.length; i++) + hash = 37 * hashCode(xa[i]); + return hash; + } + + public boolean equals (Object obj) + { + if (obj == null || ! (obj instanceof DateFormatSymbols)) + return false; + DateFormatSymbols other = (DateFormatSymbols) obj; + return (equals(ampms, other.ampms) + && equals(eras, other.eras) + && equals(localPatternChars, other.localPatternChars) + && equals(months, other.months) + && equals(shortMonths, other.shortMonths) + && equals(shortWeekdays, other.shortWeekdays) + && equals(weekdays, other.weekdays) + && equals(zoneStrings, other.zoneStrings)); + } + + public int hashCode () + { + return (hashCode(ampms) + ^ hashCode(eras) + ^ hashCode(localPatternChars) + ^ hashCode(months) + ^ hashCode(shortMonths) + ^ hashCode(shortWeekdays) + ^ hashCode(weekdays) + ^ hashCode(zoneStrings)); + } +} diff --git a/libjava/java/text/DecimalFormat.java b/libjava/java/text/DecimalFormat.java new file mode 100644 index 00000000000..9ea9d921ec1 --- /dev/null +++ b/libjava/java/text/DecimalFormat.java @@ -0,0 +1,983 @@ +// DecimalFormat.java - Localized number formatting. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.util.Locale; +import java.util.MissingResourceException; +import java.util.ResourceBundle; + +/** + * @author Tom Tromey + * @date March 4, 1999 + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 from http://www.javasoft.com. + * Status: Believed complete and correct to 1.2, except serialization. + * Note however that the docs are very unclear about how format parsing + * should work. No doubt there are problems here. + */ + +public class DecimalFormat extends NumberFormat +{ + // This is a helper for applyPatternWithSymbols. It reads a prefix + // or a suffix. It can cause some side-effects. + private final int scanFix (String pattern, int index, StringBuffer buf, + String patChars, DecimalFormatSymbols syms, + boolean is_suffix) + throws ParseException + { + int len = pattern.length(); + buf.setLength(0); + boolean multiplierSet = false; + while (index < len) + { + char c = pattern.charAt(index); + if (c == '\'' && index + 1 < len + && pattern.charAt(index + 1) == '\'') + { + buf.append(c); + ++index; + } + else if (c == '\'' && index + 2 < len + && pattern.charAt(index + 2) == '\'') + { + buf.append(pattern.charAt(index + 1)); + index += 2; + } + else if (c == '\u00a4') + { + if (index + 1 < len && pattern.charAt(index + 1) == '\u00a4') + { + buf.append(syms.getInternationalCurrencySymbol()); + ++index; + } + else + buf.append(syms.getCurrencySymbol()); + } + else if (is_suffix && c == syms.getPercent()) + { + if (multiplierSet) + throw new ParseException ("multiplier already set", index); + multiplierSet = true; + multiplier = 100; + buf.append(c); + } + else if (is_suffix && c == syms.getPerMill()) + { + if (multiplierSet) + throw new ParseException ("multiplier already set", index); + multiplierSet = true; + multiplier = 1000; + buf.append(c); + } + else if (patChars.indexOf(c) != -1) + { + // This is a pattern character. + break; + } + else + buf.append(c); + ++index; + } + + return index; + } + + // A helper which reads a number format. + private final int scanFormat (String pattern, int index, + String patChars, DecimalFormatSymbols syms, + boolean is_positive) + throws ParseException + { + int max = pattern.length(); + + int countSinceGroup = 0; + int zeroCount = 0; + boolean saw_group = false; + + // + // Scan integer part. + // + while (index < max) + { + char c = pattern.charAt(index); + + if (c == syms.getDigit()) + { + if (zeroCount > 0) + throw new ParseException ("digit mark following zero", index); + ++countSinceGroup; + } + else if (c == syms.getZeroDigit()) + { + ++zeroCount; + ++countSinceGroup; + } + else if (c == syms.getGroupingSeparator()) + { + countSinceGroup = 0; + saw_group = true; + } + else + break; + + ++index; + } + + // We can only side-effect when parsing the positive format. + if (is_positive) + { + groupingUsed = saw_group; + groupingSize = (byte) countSinceGroup; + minimumIntegerDigits = zeroCount; + } + + // Early termination. + if (index == max || pattern.charAt(index) == syms.getGroupingSeparator()) + { + if (is_positive) + decimalSeparatorAlwaysShown = false; + return index; + } + + if (pattern.charAt(index) == syms.getDecimalSeparator()) + { + ++index; + + // + // Scan fractional part. + // + int hashCount = 0; + zeroCount = 0; + while (index < max) + { + char c = pattern.charAt(index); + if (c == syms.getZeroDigit()) + { + if (hashCount > 0) + throw new ParseException ("zero mark following digit", + index); + ++zeroCount; + } + else if (c == syms.getDigit()) + { + ++hashCount; + } + else if (c != syms.getExponential() + && c != syms.getPatternSeparator() + && patChars.indexOf(c) != -1) + throw new ParseException ("unexpected special character", + index); + else + break; + + ++index; + } + + if (is_positive) + { + maximumFractionDigits = hashCount + zeroCount; + minimumFractionDigits = zeroCount; + } + + if (index == max) + return index; + } + + if (pattern.charAt(index) == syms.getExponential()) + { + // + // Scan exponential format. + // + zeroCount = 0; + ++index; + while (index < max) + { + char c = pattern.charAt(index); + if (c == syms.getZeroDigit()) + ++zeroCount; + else if (c == syms.getDigit()) + { + if (zeroCount > 0) + throw new + ParseException ("digit mark following zero in exponent", + index); + } + else if (patChars.indexOf(c) != -1) + throw new ParseException ("unexpected special character", + index); + else + break; + + ++index; + } + + if (is_positive) + { + useExponentialNotation = true; + minExponentDigits = (byte) zeroCount; + } + } + + return index; + } + + // This helper function creates a string consisting of all the + // characters which can appear in a pattern and must be quoted. + private final String patternChars (DecimalFormatSymbols syms) + { + StringBuffer buf = new StringBuffer (); + buf.append(syms.getDecimalSeparator()); + buf.append(syms.getDigit()); + buf.append(syms.getExponential()); + buf.append(syms.getGroupingSeparator()); + // Adding this one causes pattern application to fail. + // Of course, omitting is causes toPattern to fail. + // ... but we already have bugs there. FIXME. + // buf.append(syms.getMinusSign()); + buf.append(syms.getPatternSeparator()); + buf.append(syms.getPercent()); + buf.append(syms.getPerMill()); + buf.append(syms.getZeroDigit()); + buf.append('\u00a4'); + return buf.toString(); + } + + private final void applyPatternWithSymbols (String pattern, + DecimalFormatSymbols syms) + throws ParseException + { + // Initialize to the state the parser expects. + negativePrefix = ""; + negativeSuffix = ""; + positivePrefix = ""; + positiveSuffix = ""; + decimalSeparatorAlwaysShown = false; + groupingSize = 0; + minExponentDigits = 0; + multiplier = 1; + useExponentialNotation = false; + groupingUsed = false; + maximumFractionDigits = 0; + maximumIntegerDigits = 309; + minimumFractionDigits = 0; + minimumIntegerDigits = 1; + + StringBuffer buf = new StringBuffer (); + String patChars = patternChars (syms); + + int max = pattern.length(); + int index = scanFix (pattern, 0, buf, patChars, syms, false); + positivePrefix = buf.toString(); + + index = scanFormat (pattern, index, patChars, syms, true); + + index = scanFix (pattern, index, buf, patChars, syms, true); + positiveSuffix = buf.toString(); + + if (index == pattern.length()) + { + // No negative info. + negativePrefix = null; + negativeSuffix = null; + } + else + { + if (pattern.charAt(index) != syms.getPatternSeparator()) + throw new ParseException ("separator character expected", index); + + index = scanFix (pattern, index + 1, buf, patChars, syms, false); + negativePrefix = buf.toString(); + + // We parse the negative format for errors but we don't let + // it side-effect this object. + index = scanFormat (pattern, index, patChars, syms, false); + + index = scanFix (pattern, index, buf, patChars, syms, true); + negativeSuffix = buf.toString(); + + if (index != pattern.length()) + throw new ParseException ("end of pattern expected", index); + } + } + + public void applyLocalizedPattern (String pattern) throws ParseException + { + applyPatternWithSymbols (pattern, symbols); + } + + public void applyPattern (String pattern) throws ParseException + { + applyPatternWithSymbols (pattern, nonLocalizedSymbols); + } + + public Object clone () + { + return new DecimalFormat (this); + } + + private DecimalFormat (DecimalFormat dup) + { + decimalSeparatorAlwaysShown = dup.decimalSeparatorAlwaysShown; + groupingSize = dup.groupingSize; + minExponentDigits = dup.minExponentDigits; + multiplier = dup.multiplier; + negativePrefix = dup.negativePrefix; + negativeSuffix = dup.negativeSuffix; + positivePrefix = dup.positivePrefix; + positiveSuffix = dup.positiveSuffix; + symbols = (DecimalFormatSymbols) dup.symbols.clone(); + useExponentialNotation = dup.useExponentialNotation; + } + + public DecimalFormat () + { + this ("#,##0.###"); + } + + public DecimalFormat (String pattern) + { + this (pattern, new DecimalFormatSymbols ()); + } + + public DecimalFormat (String pattern, DecimalFormatSymbols symbols) + { + this.symbols = symbols; + // The docs imply that the constructor turns a ParseException + // into an IllegalArgumentException. + try + { + applyPattern (pattern); + } + catch (ParseException x) + { + throw new IllegalArgumentException (x.getMessage()); + } + } + + private final boolean equals (String s1, String s2) + { + if (s1 == null || s2 == null) + return s1 == s2; + return s1.equals(s2); + } + + public boolean equals (Object obj) + { + if (! (obj instanceof DecimalFormat)) + return false; + DecimalFormat dup = (DecimalFormat) obj; + return (decimalSeparatorAlwaysShown == dup.decimalSeparatorAlwaysShown + && groupingSize == dup.groupingSize + && minExponentDigits == dup.minExponentDigits + && multiplier == dup.multiplier + && equals(negativePrefix, dup.negativePrefix) + && equals(negativeSuffix, dup.negativeSuffix) + && equals(positivePrefix, dup.positivePrefix) + && equals(positiveSuffix, dup.positiveSuffix) + && symbols.equals(dup.symbols) + && useExponentialNotation == dup.useExponentialNotation); + } + + public StringBuffer format (double number, StringBuffer dest, + FieldPosition fieldPos) + { + // A very special case. + if (Double.isNaN(number)) + { + dest.append(symbols.getNaN()); + if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD) + { + int index = dest.length(); + fieldPos.setBeginIndex(index - symbols.getNaN().length()); + fieldPos.setEndIndex(index); + } + return dest; + } + + boolean is_neg = number < 0; + if (is_neg) + { + if (negativePrefix != null) + dest.append(negativePrefix); + else + { + dest.append(symbols.getMinusSign()); + dest.append(positivePrefix); + } + number = - number; + } + else + dest.append(positivePrefix); + + int integerBeginIndex = dest.length(); + int integerEndIndex = 0; + if (Double.isInfinite (number)) + { + dest.append(symbols.getInfinity()); + integerEndIndex = dest.length(); + } + else + { + number *= multiplier; + + // Compute exponent. + long exponent = 0; + double baseNumber; + if (useExponentialNotation) + { + exponent = (long) (Math.log(number) / Math.log(10)); + if (minimumIntegerDigits > 0) + exponent -= minimumIntegerDigits - 1; + baseNumber = (long) (number / Math.pow(10.0, exponent)); + } + else + baseNumber = number; + + // Round to the correct number of digits. + baseNumber += 5 * Math.pow(10.0, - maximumFractionDigits - 1); + + int index = dest.length(); + double intPart = Math.floor(baseNumber); + int count = 0; + while (count < maximumIntegerDigits + && (intPart > 0 || count < minimumIntegerDigits)) + { + long dig = (long) (intPart % 10); + intPart = Math.floor(intPart / 10); + + // Append group separator if required. + if (groupingUsed && count > 0 && count % groupingSize == 0) + dest.insert(index, symbols.getGroupingSeparator()); + + dest.insert(index, (char) (symbols.getZeroDigit() + dig)); + + ++count; + } + + integerEndIndex = dest.length(); + + int decimal_index = integerEndIndex; + int consecutive_zeros = 0; + int total_digits = 0; + + // Strip integer part from NUMBER. + double fracPart = baseNumber - Math.floor(baseNumber); + for (count = 0; + count < maximumFractionDigits + && (fracPart != 0 || count < minimumFractionDigits); + ++count) + { + ++total_digits; + fracPart *= 10; + long dig = (long) fracPart; + if (dig == 0) + ++consecutive_zeros; + else + consecutive_zeros = 0; + dest.append((char) (symbols.getZeroDigit() + dig)); + + // Strip integer part from FRACPART. + fracPart = fracPart - Math.floor (fracPart); + } + + // Strip extraneous trailing `0's. We can't always detect + // these in the loop. + int extra_zeros = Math.min (consecutive_zeros, + total_digits - minimumFractionDigits); + if (extra_zeros > 0) + { + dest.setLength(dest.length() - extra_zeros); + total_digits -= extra_zeros; + } + + // If required, add the decimal symbol. + if (decimalSeparatorAlwaysShown + || total_digits > 0) + { + dest.insert(decimal_index, symbols.getDecimalSeparator()); + if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD) + { + fieldPos.setBeginIndex(decimal_index + 1); + fieldPos.setEndIndex(dest.length()); + } + } + + // Finally, print the exponent. + if (useExponentialNotation) + { + dest.append(symbols.getExponential()); + dest.append(exponent < 0 ? '-' : '+'); + index = dest.length(); + for (count = 0; + exponent > 0 || count < minExponentDigits; + ++count) + { + long dig = exponent % 10; + exponent /= 10; + dest.insert(index, (char) (symbols.getZeroDigit() + dig)); + } + } + } + + if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD) + { + fieldPos.setBeginIndex(integerBeginIndex); + fieldPos.setEndIndex(integerEndIndex); + } + + dest.append((is_neg && negativeSuffix != null) + ? negativeSuffix + : positiveSuffix); + return dest; + } + + public StringBuffer format (long number, StringBuffer dest, + FieldPosition fieldPos) + { + // If using exponential notation, we just format as a double. + if (useExponentialNotation) + return format ((double) number, dest, fieldPos); + + boolean is_neg = number < 0; + if (is_neg) + { + if (negativePrefix != null) + dest.append(negativePrefix); + else + { + dest.append(symbols.getMinusSign()); + dest.append(positivePrefix); + } + number = - number; + } + else + dest.append(positivePrefix); + + int integerBeginIndex = dest.length(); + int index = dest.length(); + int count = 0; + while (count < maximumIntegerDigits + && (number > 0 || count < minimumIntegerDigits)) + { + long dig = number % 10; + number /= 10; + // NUMBER and DIG will be less than 0 if the original number + // was the most negative long. + if (dig < 0) + { + dig = - dig; + number = - number; + } + + // Append group separator if required. + if (groupingUsed && count > 0 && count % groupingSize == 0) + dest.insert(index, symbols.getGroupingSeparator()); + + dest.insert(index, (char) (symbols.getZeroDigit() + dig)); + + ++count; + } + + if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD) + { + fieldPos.setBeginIndex(integerBeginIndex); + fieldPos.setEndIndex(dest.length()); + } + + if (decimalSeparatorAlwaysShown || minimumFractionDigits > 0) + { + dest.append(symbols.getDecimalSeparator()); + if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD) + { + fieldPos.setBeginIndex(dest.length()); + fieldPos.setEndIndex(dest.length() + minimumFractionDigits); + } + } + + for (count = 0; count < minimumFractionDigits; ++count) + dest.append(symbols.getZeroDigit()); + + dest.append((is_neg && negativeSuffix != null) + ? negativeSuffix + : positiveSuffix); + return dest; + } + + public DecimalFormatSymbols getDecimalFormatSymbols () + { + return symbols; + } + + public int getGroupingSize () + { + return groupingSize; + } + + public int getMultiplier () + { + return multiplier; + } + + public String getNegativePrefix () + { + return negativePrefix; + } + + public String getNegativeSuffix () + { + return negativeSuffix; + } + + public String getPositivePrefix () + { + return positivePrefix; + } + + public String getPositiveSuffix () + { + return positiveSuffix; + } + + public int hashCode () + { + int hash = (negativeSuffix.hashCode() ^ negativePrefix.hashCode() + ^positivePrefix.hashCode() ^ positiveSuffix.hashCode()); + // FIXME. + return hash; + } + + public boolean isDecimalSeparatorAlwaysShown () + { + return decimalSeparatorAlwaysShown; + } + + public Number parse (String str, ParsePosition pos) + { + // Our strategy is simple: copy the text into a buffer, + // translating or omitting locale-specific information. Then + // let Double or Long convert the number for us. + + boolean is_neg = false; + int index = pos.getIndex(); + StringBuffer buf = new StringBuffer (); + + // We have to check both prefixes, because one might be empty. + // We want to pick the longest prefix that matches. + boolean got_pos = str.startsWith(positivePrefix, index); + String np = (negativePrefix != null + ? negativePrefix + : positivePrefix + symbols.getMinusSign()); + boolean got_neg = str.startsWith(np, index); + + if (got_pos && got_neg) + { + // By checking this way, we preserve ambiguity in the case + // where the negative format differs only in suffix. We + // check this again later. + if (np.length() > positivePrefix.length()) + { + is_neg = true; + index += np.length(); + } + else + index += positivePrefix.length(); + } + else if (got_neg) + { + is_neg = true; + index += np.length(); + } + else if (got_pos) + index += positivePrefix.length(); + else + { + pos.setErrorIndex (index); + return null; + } + + // FIXME: handle Inf and NaN. + + // FIXME: do we have to respect minimum/maxmimum digit stuff? + // What about leading zeros? What about multiplier? + + int start_index = index; + int max = str.length(); + char zero = symbols.getZeroDigit(); + int last_group = -1; + boolean int_part = true; + boolean exp_part = false; + for (; index < max; ++index) + { + char c = str.charAt(index); + + // FIXME: what about grouping size? + if (groupingUsed && c == symbols.getGroupingSeparator()) + { + if (last_group != -1 + && (index - last_group) % groupingSize != 0) + { + pos.setErrorIndex(index); + return null; + } + last_group = index; + } + else if (c >= zero && c <= zero + 9) + { + buf.append((char) (c - zero + '0')); + exp_part = false; + } + else if (parseIntegerOnly) + break; + else if (c == symbols.getDecimalSeparator()) + { + if (last_group != -1 + && (index - last_group) % groupingSize != 0) + { + pos.setErrorIndex(index); + return null; + } + buf.append('.'); + int_part = false; + } + else if (c == symbols.getExponential()) + { + buf.append('E'); + int_part = false; + exp_part = true; + } + else if (exp_part + && (c == '+' || c == '-' || c == symbols.getMinusSign())) + { + // For exponential notation. + buf.append(c); + } + else + break; + } + + if (index == start_index) + { + // Didn't see any digits. + pos.setErrorIndex(index); + return null; + } + + // Check the suffix. We must do this before converting the + // buffer to a number to handle the case of a number which is + // the most negative Long. + boolean got_pos_suf = str.startsWith(positiveSuffix, index); + String ns = (negativePrefix == null ? positiveSuffix : negativeSuffix); + boolean got_neg_suf = str.startsWith(ns, index); + if (is_neg) + { + if (! got_neg_suf) + { + pos.setErrorIndex(index); + return null; + } + } + else if (got_pos && got_neg && got_neg_suf) + { + is_neg = true; + } + else if (got_pos != got_pos_suf && got_neg != got_neg_suf) + { + pos.setErrorIndex(index); + return null; + } + + String suffix = is_neg ? ns : positiveSuffix; + if (is_neg) + buf.insert(0, '-'); + + String t = buf.toString(); + Number result = null; + try + { + result = new Long (t); + } + catch (NumberFormatException x1) + { + try + { + result = new Double (t); + } + catch (NumberFormatException x2) + { + } + } + if (result == null) + { + pos.setErrorIndex(index); + return null; + } + + pos.setIndex(index + suffix.length()); + + return result; + } + + public void setDecimalFormatSymbols (DecimalFormatSymbols newSymbols) + { + symbols = newSymbols; + } + + public void setDecimalSeparatorAlwaysShown (boolean newValue) + { + decimalSeparatorAlwaysShown = newValue; + } + + public void setGroupingSize (int groupSize) + { + groupingSize = (byte) groupSize; + } + + public void setMaximumFractionDigits (int newValue) + { + maximumFractionDigits = Math.min(newValue, 340); + } + + public void setMaximumIntegerDigits (int newValue) + { + maximumIntegerDigits = Math.min(newValue, 309); + } + + public void setMinimumFractionDigits (int newValue) + { + minimumFractionDigits = Math.min(newValue, 340); + } + + public void setMinimumIntegerDigits (int newValue) + { + minimumIntegerDigits = Math.min(newValue, 309); + } + + public void setMultiplier (int newValue) + { + multiplier = newValue; + } + + public void setNegativePrefix (String newValue) + { + negativePrefix = newValue; + } + + public void setNegativeSuffix (String newValue) + { + negativeSuffix = newValue; + } + + public void setPositivePrefix (String newValue) + { + positivePrefix = newValue; + } + + public void setPositiveSuffix (String newValue) + { + positiveSuffix = newValue; + } + + private final void quoteFix (StringBuffer buf, String text, String patChars) + { + int len = text.length(); + for (int index = 0; index < len; ++index) + { + char c = text.charAt(index); + if (patChars.indexOf(c) != -1) + { + buf.append('\''); + buf.append(c); + buf.append('\''); + } + else + buf.append(c); + } + } + + private final String computePattern (DecimalFormatSymbols syms) + { + StringBuffer mainPattern = new StringBuffer (); + // We have to at least emit a zero for the minimum number of + // digits. Past that we need hash marks up to the grouping + // separator (and one beyond). + int total_digits = Math.max(minimumIntegerDigits, + groupingUsed ? groupingSize + 1: 0); + for (int i = 0; i < total_digits - minimumIntegerDigits; ++i) + mainPattern.append(syms.getDigit()); + for (int i = total_digits - minimumIntegerDigits; i < total_digits; ++i) + mainPattern.append(syms.getZeroDigit()); + // Inserting the gropuing operator afterwards is easier. + if (groupingUsed) + mainPattern.insert(mainPattern.length() - groupingSize, + syms.getGroupingSeparator()); + // See if we need decimal info. + if (minimumFractionDigits > 0 || maximumFractionDigits > 0 + || decimalSeparatorAlwaysShown) + mainPattern.append(syms.getDecimalSeparator()); + for (int i = 0; i < minimumFractionDigits; ++i) + mainPattern.append(syms.getZeroDigit()); + for (int i = minimumFractionDigits; i < maximumFractionDigits; ++i) + mainPattern.append(syms.getDigit()); + if (useExponentialNotation) + { + mainPattern.append(syms.getExponential()); + for (int i = 0; i < minExponentDigits; ++i) + mainPattern.append(syms.getZeroDigit()); + if (minExponentDigits == 0) + mainPattern.append(syms.getDigit()); + } + + String main = mainPattern.toString(); + String patChars = patternChars (syms); + mainPattern.setLength(0); + + quoteFix (mainPattern, positivePrefix, patChars); + mainPattern.append(main); + quoteFix (mainPattern, positiveSuffix, patChars); + + if (negativePrefix != null) + { + quoteFix (mainPattern, negativePrefix, patChars); + mainPattern.append(main); + quoteFix (mainPattern, negativeSuffix, patChars); + } + + return mainPattern.toString(); + } + + public String toLocalizedPattern () + { + return computePattern (symbols); + } + + public String toPattern () + { + return computePattern (nonLocalizedSymbols); + } + + // These names are fixed by the serialization spec. + private boolean decimalSeparatorAlwaysShown; + private byte groupingSize; + private byte minExponentDigits; + private int multiplier; + private String negativePrefix; + private String negativeSuffix; + private String positivePrefix; + private String positiveSuffix; + private DecimalFormatSymbols symbols; + private boolean useExponentialNotation; + + // The locale-independent pattern symbols happen to be the same as + // the US symbols. + private static final DecimalFormatSymbols nonLocalizedSymbols + = new DecimalFormatSymbols (Locale.US); +} diff --git a/libjava/java/text/DecimalFormatSymbols.java b/libjava/java/text/DecimalFormatSymbols.java new file mode 100644 index 00000000000..783cb6f7f50 --- /dev/null +++ b/libjava/java/text/DecimalFormatSymbols.java @@ -0,0 +1,293 @@ +// DecimalFormatSymbols.java - Symbols used to format numbers. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.io.Serializable; +import java.util.Locale; +import java.util.MissingResourceException; +import java.util.ResourceBundle; + +/** + * @author Tom Tromey + * @date February 24, 1999 + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 from http://www.javasoft.com. + * Status: Believed complete and correct to 1.2, except serialization. + */ + +public final class DecimalFormatSymbols implements Cloneable, Serializable +{ + public Object clone () + { + return new DecimalFormatSymbols (this); + } + + private DecimalFormatSymbols (DecimalFormatSymbols orig) + { + this.currencySymbol = orig.currencySymbol; + this.decimalSeparator = orig.decimalSeparator; + this.digit = orig.digit; + this.exponential = orig.exponential; + this.groupingSeparator = orig.groupingSeparator; + this.infinity = orig.infinity; + this.intlCurrencySymbol = orig.intlCurrencySymbol; + this.minusSign = orig.minusSign; + this.NaN = orig.NaN; + this.patternSeparator = orig.patternSeparator; + this.percent = orig.percent; + this.perMill = orig.perMill; + this.zeroDigit = orig.zeroDigit; + } + + public DecimalFormatSymbols () + { + this (Locale.getDefault()); + } + + private final String safeGetString (ResourceBundle bundle, + String name, String def) + { + if (bundle != null) + { + try + { + return bundle.getString(name); + } + catch (MissingResourceException x) + { + } + } + return def; + } + + public final char safeGetChar (ResourceBundle bundle, + String name, char def) + { + String r = null; + if (bundle != null) + { + try + { + r = bundle.getString(name); + } + catch (MissingResourceException x) + { + } + } + if (r == null || r.length() < 1) + return def; + return r.charAt(0); + } + + public DecimalFormatSymbols (Locale loc) + { + ResourceBundle res; + try + { + res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc); + } + catch (MissingResourceException x) + { + res = null; + } + currencySymbol = safeGetString (res, "currencySymbol", "$"); + decimalSeparator = safeGetChar (res, "decimalSeparator", '.'); + digit = safeGetChar (res, "digit", '#'); + exponential = safeGetChar (res, "exponential", 'E'); + groupingSeparator = safeGetChar (res, "groupingSeparator", ','); + infinity = safeGetString (res, "infinity", "\u221e"); + // FIXME: default? + intlCurrencySymbol = safeGetString (res, "intlCurrencySymbol", "$"); + minusSign = safeGetChar (res, "minusSign", '-'); + NaN = safeGetString (res, "NaN", "\ufffd"); + patternSeparator = safeGetChar (res, "patternSeparator", ';'); + percent = safeGetChar (res, "percent", '%'); + perMill = safeGetChar (res, "perMill", '\u2030'); + zeroDigit = safeGetChar (res, "zeroDigit", '0'); + } + + public boolean equals (Object obj) + { + if (! (obj instanceof DecimalFormatSymbols)) + return false; + DecimalFormatSymbols dfs = (DecimalFormatSymbols) obj; + return (currencySymbol.equals(dfs.currencySymbol) + && decimalSeparator == dfs.decimalSeparator + && digit == dfs.digit + && exponential == dfs.exponential + && groupingSeparator == dfs.groupingSeparator + && infinity.equals(dfs.infinity) + && intlCurrencySymbol.equals(dfs.intlCurrencySymbol) + && minusSign == dfs.minusSign + && NaN.equals(dfs.NaN) + && patternSeparator == dfs.patternSeparator + && percent == dfs.percent + && perMill == dfs.perMill + && zeroDigit == dfs.zeroDigit); + } + + public String getCurrencySymbol () + { + return currencySymbol; + } + + public char getDecimalSeparator () + { + return decimalSeparator; + } + + public char getDigit () + { + return digit; + } + + // This is our own extension. + char getExponential () + { + return exponential; + } + + public char getGroupingSeparator () + { + return groupingSeparator; + } + + public String getInfinity () + { + return infinity; + } + + public String getInternationalCurrencySymbol () + { + return intlCurrencySymbol; + } + + public char getMinusSign () + { + return minusSign; + } + + public String getNaN () + { + return NaN; + } + + public char getPatternSeparator () + { + return patternSeparator; + } + + public char getPercent () + { + return percent; + } + + public char getPerMill () + { + return perMill; + } + + public char getZeroDigit () + { + return zeroDigit; + } + + public int hashCode () + { + // Compute based on zero digit, grouping separator, and decimal + // separator -- JCL book. This probably isn't a very good hash + // code. + return zeroDigit << 16 + groupingSeparator << 8 + decimalSeparator; + } + + public void setCurrenySymbol (String currency) + { + currencySymbol = currency; + } + + public void setDecimalSeparator (char decimalSep) + { + decimalSeparator = decimalSep; + } + + public void setDigit (char digit) + { + this.digit = digit; + } + + // This is our own extension. + void setExponential (char exp) + { + exponential = exp; + } + + public void setGroupingSeparator (char groupSep) + { + groupingSeparator = groupSep; + } + + public void setInfinity (String infinity) + { + this.infinity = infinity; + } + + public void setInternationalCurrencySymbol (String currency) + { + intlCurrencySymbol = currency; + } + + public void setMinusSign (char minusSign) + { + this.minusSign = minusSign; + } + + public void setNaN (String nan) + { + NaN = nan; + } + + public void setPatternSeparator (char patternSep) + { + patternSeparator = patternSep; + } + + public void setPercent (char percent) + { + this.percent = percent; + } + + public void setPerMill (char perMill) + { + this.perMill = perMill; + } + + public void setZeroDigit (char zeroDigit) + { + this.zeroDigit = zeroDigit; + } + + // The names of the instance variables are fixed by the + // serialization spec. + private String currencySymbol; + private char decimalSeparator; + private char digit; + private char exponential; + private char groupingSeparator; + private String infinity; + private String intlCurrencySymbol; + private char minusSign; + private String NaN; + private char patternSeparator; + private char percent; + private char perMill; + private char zeroDigit; +} diff --git a/libjava/java/text/FieldPosition.java b/libjava/java/text/FieldPosition.java new file mode 100644 index 00000000000..2f8c0935b48 --- /dev/null +++ b/libjava/java/text/FieldPosition.java @@ -0,0 +1,65 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +/** + * @author Per Bothner + * @date October 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + * Includes JDK 1.2 methods. + */ + +public class FieldPosition +{ + int field; + int beginIndex; + int endIndex; + + public FieldPosition (int field) + { + this.field = field; + } + + public int getField () + { + return field; + } + + public int getBeginIndex () + { + return beginIndex; + } + + public int getEndIndex () + { + return endIndex; + } + + public void setBeginIndex (int index) + { + beginIndex = index; + } + + public void setEndIndex (int index) + { + endIndex = index; + } + + public boolean equals (Object obj) + { + if (! (obj instanceof FieldPosition)) + return false; + FieldPosition other = (FieldPosition) obj; + return (field == other.field + && beginIndex == other.beginIndex && endIndex == other.endIndex); + } +} diff --git a/libjava/java/text/Format.java b/libjava/java/text/Format.java new file mode 100644 index 00000000000..d2c918b9072 --- /dev/null +++ b/libjava/java/text/Format.java @@ -0,0 +1,51 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +/** + * @author Per Bothner + * @date October 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public abstract class Format implements java.io.Serializable, Cloneable +{ + public Format () + { + } + + public abstract StringBuffer format (Object obj, + StringBuffer sbuf, FieldPosition pos); + + public final String format (Object obj) + { + StringBuffer sbuf = new StringBuffer(); + format(obj, sbuf, new FieldPosition(0)); + return sbuf.toString(); + } + + public abstract Object parseObject (String source, ParsePosition pos); + + public Object parseObject (String source) throws ParseException + { + ParsePosition pos = new ParsePosition(0); + Object result = parseObject (source, pos); + if (result == null) + { + int index = pos.getErrorIndex(); + if (index < 0) + index = pos.getIndex(); + throw new ParseException("parseObject failed", index); + } + return result; + } +} diff --git a/libjava/java/text/MessageFormat.java b/libjava/java/text/MessageFormat.java new file mode 100644 index 00000000000..8b422357966 --- /dev/null +++ b/libjava/java/text/MessageFormat.java @@ -0,0 +1,543 @@ +// MessageFormat.java - Localized message formatting. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.util.Date; +import java.util.Locale; +import java.util.Vector; + +/** + * @author Tom Tromey + * @date March 3, 1999 + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 from http://www.javasoft.com. + * Status: Believed complete and correct to 1.2, except serialization. + * and parsing. + */ + +final class MessageFormatElement +{ + // Argument number. + int argNumber; + // Formatter to be used. This is the format set by setFormat. + Format setFormat; + // Formatter to be used based on the type. + Format format; + + // Argument will be checked to make sure it is an instance of this + // class. + Class formatClass; + + // Formatter type. + String type; + // Formatter style. + String style; + + // Text to follow this element. + String trailer; + + // FIXME: shouldn't need this. + Class forName (String name) + { + try + { + return Class.forName (name); + } + catch (ClassNotFoundException x) + { + } + return null; + } + + // Recompute the locale-based formatter. + void setLocale (Locale loc) + { + if (type == null) + ; + else if (type.equals("number")) + { + // FIXME: named class literal. + // formatClass = Number.class; + formatClass = forName ("java.lang.Number"); + + if (style == null) + format = NumberFormat.getInstance(loc); + else if (style.equals("currency")) + format = NumberFormat.getCurrencyInstance(loc); + else if (style.equals("percent")) + format = NumberFormat.getPercentInstance(loc); + else if (style.equals("integer")) + { + NumberFormat nf = NumberFormat.getNumberInstance(loc); + nf.setMaximumFractionDigits(0); + nf.setGroupingUsed(false); + format = nf; + } + else + { + format = NumberFormat.getNumberInstance(loc); + DecimalFormat df = (DecimalFormat) format; + try + { + df.applyPattern(style); + } + catch (ParseException x) + { + throw new IllegalArgumentException (x.getMessage()); + } + } + } + else if (type.equals("time") || type.equals("date")) + { + // FIXME: named class literal. + // formatClass = Date.class; + formatClass = forName ("java.util.Date"); + + int val = DateFormat.DEFAULT; + if (style == null) + ; + if (style.equals("short")) + val = DateFormat.SHORT; + else if (style.equals("medium")) + val = DateFormat.MEDIUM; + else if (style.equals("long")) + val = DateFormat.LONG; + else if (style.equals("full")) + val = DateFormat.FULL; + + if (type.equals("time")) + format = DateFormat.getTimeInstance(val, loc); + else + format = DateFormat.getDateInstance(val, loc); + + if (style != null && val == DateFormat.DEFAULT) + { + SimpleDateFormat sdf = (SimpleDateFormat) format; + sdf.applyPattern(style); + } + } + else if (type.equals("choice")) + { + // FIXME: named class literal. + // formatClass = Number.class; + formatClass = forName ("java.lang.Number"); + + if (style == null) + throw new + IllegalArgumentException ("style required for choice format"); + format = new ChoiceFormat (style); + } + } +} + +public class MessageFormat extends Format +{ + // Helper that returns the text up to the next format opener. The + // text is put into BUFFER. Returns index of character after end of + // string. Throws IllegalArgumentException on error. + private static final int scanString (String pat, int index, + StringBuffer buffer) + { + int max = pat.length(); + buffer.setLength(0); + for (; index < max; ++index) + { + char c = pat.charAt(index); + if (c == '\'' && index + 2 < max && pat.charAt(index + 2) == '\'') + { + buffer.append(pat.charAt(index + 1)); + index += 2; + } + else if (c == '\'' && index + 1 < max + && pat.charAt(index + 1) == '\'') + { + buffer.append(c); + ++index; + } + else if (c == '{') + break; + else if (c == '}') + throw new IllegalArgumentException (); + else + buffer.append(c); + } + return index; + } + + // This helper retrieves a single part of a format element. Returns + // the index of the terminating character. + private static final int scanFormatElement (String pat, int index, + StringBuffer buffer, + char term) + { + int max = pat.length(); + buffer.setLength(0); + int brace_depth = 1; + + for (; index < max; ++index) + { + char c = pat.charAt(index); + if (c == '\'' && index + 2 < max && pat.charAt(index + 2) == '\'') + { + buffer.append(c); + buffer.append(pat.charAt(index + 1)); + buffer.append(c); + index += 2; + } + else if (c == '\'' && index + 1 < max + && pat.charAt(index + 1) == '\'') + { + buffer.append(c); + ++index; + } + else if (c == '{') + { + buffer.append(c); + ++brace_depth; + } + else if (c == '}') + { + if (--brace_depth == 0) + break; + buffer.append(c); + } + // Check for TERM after braces, because TERM might be `}'. + else if (c == term) + break; + else + buffer.append(c); + } + return index; + } + + // This is used to parse a format element and whatever non-format + // text might trail it. + private static final int scanFormat (String pat, int index, + StringBuffer buffer, Vector elts, + Locale locale) + { + MessageFormatElement mfe = new MessageFormatElement (); + elts.addElement(mfe); + + int max = pat.length(); + + // Skip the opening `{'. + ++index; + + // Fetch the argument number. + index = scanFormatElement (pat, index, buffer, ','); + try + { + mfe.argNumber = Integer.parseInt(buffer.toString()); + } + catch (NumberFormatException nfx) + { + throw new IllegalArgumentException (); + } + + // Extract the element format. + if (index < max && pat.charAt(index) == ',') + { + index = scanFormatElement (pat, index + 1, buffer, ','); + mfe.type = buffer.toString(); + + // Extract the style. + if (index < max && pat.charAt(index) == ',') + { + index = scanFormatElement (pat, index + 1, buffer, '}'); + mfe.style = buffer.toString (); + } + } + + // Advance past the last terminator. + if (index >= max || pat.charAt(index) != '}') + throw new IllegalArgumentException (); + ++index; + + // Now fetch trailing string. + index = scanString (pat, index, buffer); + mfe.trailer = buffer.toString (); + + mfe.setLocale(locale); + + return index; + } + + public void applyPattern (String newPattern) + { + pattern = newPattern; + + StringBuffer tempBuffer = new StringBuffer (); + + int index = scanString (newPattern, 0, tempBuffer); + leader = tempBuffer.toString(); + + Vector elts = new Vector (); + while (index < newPattern.length()) + index = scanFormat (newPattern, index, tempBuffer, elts, locale); + + elements = new MessageFormatElement[elts.size()]; + elts.copyInto(elements); + } + + public Object clone () + { + MessageFormat c = new MessageFormat (); + c.setLocale(locale); + c.applyPattern(pattern); + return (Object) c; + } + + public boolean equals (Object obj) + { + if (! (obj instanceof MessageFormat)) + return false; + MessageFormat mf = (MessageFormat) obj; + return (pattern.equals(mf.pattern) + && locale.equals(mf.locale)); + } + + public static String format (String pattern, Object arguments[]) + { + MessageFormat mf = new MessageFormat (pattern); + StringBuffer sb = new StringBuffer (); + FieldPosition fp = new FieldPosition (NumberFormat.INTEGER_FIELD); + return mf.format(arguments, sb, fp).toString(); + } + + public final StringBuffer format (Object arguments[], StringBuffer appendBuf, + FieldPosition ignore) + { + appendBuf.append(leader); + + for (int i = 0; i < elements.length; ++i) + { + if (elements[i].argNumber >= arguments.length) + throw new IllegalArgumentException (); + Object thisArg = arguments[elements[i].argNumber]; + + Format formatter = null; + if (elements[i].setFormat != null) + formatter = elements[i].setFormat; + else if (elements[i].format != null) + { + if (elements[i].formatClass != null + && ! elements[i].formatClass.isInstance(thisArg)) + throw new IllegalArgumentException (); + formatter = elements[i].format; + } + else if (thisArg instanceof Number) + formatter = NumberFormat.getInstance(locale); + else if (thisArg instanceof Date) + formatter = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale); + else + appendBuf.append(thisArg); + + if (formatter != null) + { + // Special-case ChoiceFormat. + if (formatter instanceof ChoiceFormat) + { + StringBuffer buf = new StringBuffer (); + // FIXME: don't actually know what is correct here. + // Can a sub-format refer to any argument, or just + // the single argument passed to it? Must test + // against JDK. + formatter.format(thisArg, buf, ignore); + MessageFormat mf = new MessageFormat (); + mf.setLocale(locale); + mf.applyPattern(buf.toString()); + formatter = mf; + } + formatter.format(thisArg, appendBuf, ignore); + } + + appendBuf.append(elements[i].trailer); + } + + return appendBuf; + } + + public final StringBuffer format (Object singleArg, StringBuffer appendBuf, + FieldPosition ignore) + { + Object[] args = new Object[1]; + args[0] = singleArg; + return format (args, appendBuf, ignore); + } + + public Format[] getFormats () + { + Format[] f = new Format[elements.length]; + for (int i = elements.length - 1; i >= 0; --i) + f[i] = elements[i].setFormat; + return f; + } + + public Locale getLocale () + { + return locale; + } + + public int hashCode () + { + // FIXME: not a very good hash. + return pattern.hashCode() + locale.hashCode(); + } + + private MessageFormat () + { + } + + public MessageFormat (String pattern) + { + applyPattern (pattern); + } + + public Object[] parse (String sourceStr, ParsePosition pos) + { + // Check initial text. + int index = pos.getIndex(); + if (! sourceStr.startsWith(leader, index)) + { + pos.setErrorIndex(index); + return null; + } + index += leader.length(); + + Vector results = new Vector (elements.length, 1); + // Now check each format. + for (int i = 0; i < elements.length; ++i) + { + Format formatter = null; + if (elements[i].setFormat != null) + formatter = elements[i].setFormat; + else if (elements[i].format != null) + formatter = elements[i].format; + + Object value = null; + if (formatter instanceof ChoiceFormat) + { + // We must special-case a ChoiceFormat because it might + // have recursive formatting. + ChoiceFormat cf = (ChoiceFormat) formatter; + String[] formats = (String[]) cf.getFormats(); + double[] limits = (double[]) cf.getLimits(); + MessageFormat subfmt = new MessageFormat (); + subfmt.setLocale(locale); + ParsePosition subpos = new ParsePosition (index); + + int j; + for (j = 0; value == null && j < limits.length; ++j) + { + subfmt.applyPattern(formats[j]); + subpos.setIndex(index); + value = subfmt.parse(sourceStr, subpos); + } + if (value != null) + { + index = subpos.getIndex(); + value = new Double (limits[j]); + } + } + else if (formatter != null) + { + pos.setIndex(index); + value = formatter.parseObject(sourceStr, pos); + if (value != null) + index = pos.getIndex(); + } + else + { + // We have a String format. This can lose in a number + // of ways, but we give it a shot. + int next_index = sourceStr.indexOf(elements[i].trailer, index); + if (next_index == -1) + { + pos.setErrorIndex(index); + return null; + } + value = sourceStr.substring(index, next_index); + index = next_index; + } + + if (value == null + || ! sourceStr.startsWith(elements[i].trailer, index)) + { + pos.setErrorIndex(index); + return null; + } + + if (elements[i].argNumber >= results.size()) + results.setSize(elements[i].argNumber + 1); + results.setElementAt(value, elements[i].argNumber); + + index += elements[i].trailer.length(); + } + + Object[] r = new Object[results.size()]; + results.copyInto(r); + return r; + } + + public Object[] parse (String sourceStr) throws ParseException + { + ParsePosition pp = new ParsePosition (0); + Object[] r = parse (sourceStr, pp); + if (r == null) + throw new ParseException ("couldn't parse string", pp.getErrorIndex()); + return r; + } + + public Object parseObject (String sourceStr, ParsePosition pos) + { + return parse (sourceStr, pos); + } + + public void setFormat (int variableNum, Format newFormat) + { + elements[variableNum].setFormat = newFormat; + } + + public void setFormats (Format[] newFormats) + { + if (newFormats.length < elements.length) + throw new IllegalArgumentException (); + int len = Math.min(newFormats.length, elements.length); + for (int i = 0; i < len; ++i) + elements[i].setFormat = newFormats[i]; + } + + public void setLocale (Locale loc) + { + locale = loc; + if (elements != null) + { + for (int i = 0; i < elements.length; ++i) + elements[i].setLocale(loc); + } + } + + public String toPattern () + { + return pattern; + } + + // The pattern string. + private String pattern; + // The locale. + private Locale locale; + // Variables. + private MessageFormatElement[] elements; + // Leader text. + private String leader; +} diff --git a/libjava/java/text/NumberFormat.java b/libjava/java/text/NumberFormat.java new file mode 100644 index 00000000000..6ee79b3b546 --- /dev/null +++ b/libjava/java/text/NumberFormat.java @@ -0,0 +1,236 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.util.Locale; +import java.util.ResourceBundle; +import java.util.MissingResourceException; + +/** + * @author Tom Tromey + * @date March 4, 1999 + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 from http://www.javasoft.com. + * Status: Believed complete and correct to 1.2, except serialization + * and getAvailableLocales. + */ + +public abstract class NumberFormat extends Format implements Cloneable +{ + public static final int INTEGER_FIELD = 0; + public static final int FRACTION_FIELD = 1; + + public final String format (long number) + { + StringBuffer sbuf = new StringBuffer(50); + format (number, sbuf, null); + return sbuf.toString(); + } + + public final StringBuffer format (Object obj, StringBuffer sbuf, + FieldPosition pos) + { + return format(((Number) obj).doubleValue(), sbuf, pos); + } + + public abstract StringBuffer format (double number, + StringBuffer sbuf, FieldPosition pos); + + public abstract StringBuffer format (long number, + StringBuffer sbuf, FieldPosition pos); + + public static Locale[] getAvailableLocales () + { + // FIXME. + return null; + } + + private static final NumberFormat computeInstance (Locale loc, + String resource, + String def) + { + ResourceBundle res; + try + { + res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc); + } + catch (MissingResourceException x) + { + res = null; + } + String fmt; + try + { + fmt = res == null ? def : res.getString(resource); + } + catch (MissingResourceException x) + { + fmt = def; + } + DecimalFormatSymbols dfs = new DecimalFormatSymbols (loc); + return new DecimalFormat (fmt, dfs); + } + + public static final NumberFormat getCurrencyInstance () + { + return getCurrencyInstance (Locale.getDefault()); + } + + public static NumberFormat getCurrencyInstance (Locale loc) + { + return computeInstance (loc, "currencyFormat", "$#,##0.00;($#,##0.00)"); + } + + public static final NumberFormat getInstance () + { + return getInstance (Locale.getDefault()); + } + + public static NumberFormat getInstance (Locale loc) + { + // For now always return a number instance. + return getNumberInstance (loc); + } + + public int getMaximumFractionDigits () + { + return maximumFractionDigits; + } + + public int getMaximumIntegerDigits () + { + return maximumIntegerDigits; + } + + public int getMinimumFractionDigits () + { + return minimumFractionDigits; + } + + public int getMinimumIntegerDigits () + { + return minimumIntegerDigits; + } + + public static final NumberFormat getNumberInstance () + { + return getNumberInstance (Locale.getDefault()); + } + + public static NumberFormat getNumberInstance (Locale loc) + { + return computeInstance (loc, "numberFormat", "#,##0.###"); + } + + public static final NumberFormat getPercentInstance () + { + return getPercentInstance (Locale.getDefault()); + } + + public static NumberFormat getPercentInstance (Locale loc) + { + return computeInstance (loc, "percentFormat", "#,##0%"); + } + + public int hashCode () + { + int hash = super.hashCode(); + hash ^= (maximumFractionDigits + maximumIntegerDigits + + minimumFractionDigits + minimumIntegerDigits); + if (groupingUsed) + hash ^= 0xf0f0; + if (parseIntegerOnly) + hash ^= 0x0f0f; + return hash; + } + + public boolean isGroupingUsed () + { + return groupingUsed; + } + + public boolean isParseIntegerOnly () + { + return parseIntegerOnly; + } + + public NumberFormat () + { + } + + public abstract Number parse (String sourceStr, ParsePosition pos); + + public Number parse (String sourceStr) throws ParseException + { + ParsePosition pp = new ParsePosition (0); + Number r = parse (sourceStr, pp); + if (r == null) + { + int index = pp.getErrorIndex(); + if (index < 0) + index = pp.getIndex(); + throw new ParseException ("couldn't parse number", index); + } + return r; + } + + public final Object parseObject (String sourceStr, ParsePosition pos) + { + return parse (sourceStr, pos); + } + + public void setGroupingUsed (boolean newValue) + { + groupingUsed = newValue; + } + + public void setMaximumFractionDigits (int newValue) + { + maximumFractionDigits = newValue; + } + + public void setMaximumIntegerDigits (int newValue) + { + maximumIntegerDigits = newValue; + } + + public void setMinimumFractionDigits (int newValue) + { + minimumFractionDigits = newValue; + } + + public void setMinimumIntegerDigits (int newValue) + { + minimumIntegerDigits = newValue; + } + + public void setParseIntegerOnly (boolean value) + { + parseIntegerOnly = value; + } + + public final String format (double number) + { + StringBuffer sbuf = new StringBuffer(50); + format (number, sbuf, null); + return sbuf.toString(); + } + + // These field names are fixed by the serialization spec. + // FIXME: serialization spec also mentions `byte' versions of the + // min/max fields. We have no use for those, so for now they are + // omitted. + protected boolean groupingUsed; + protected int maximumFractionDigits; + protected int maximumIntegerDigits; + protected int minimumFractionDigits; + protected int minimumIntegerDigits; + protected boolean parseIntegerOnly; +} diff --git a/libjava/java/text/ParseException.java b/libjava/java/text/ParseException.java new file mode 100644 index 00000000000..6bc9353bcd2 --- /dev/null +++ b/libjava/java/text/ParseException.java @@ -0,0 +1,34 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +/** + * @author Per Bothner + * @date October 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class ParseException extends Exception +{ + private int errorOffset; + + public ParseException (String msg, int errorOffset) + { + super(msg); + this.errorOffset = errorOffset; + } + + public int getErrorOffset () + { + return errorOffset; + } +} diff --git a/libjava/java/text/ParsePosition.java b/libjava/java/text/ParsePosition.java new file mode 100644 index 00000000000..4603f79259b --- /dev/null +++ b/libjava/java/text/ParsePosition.java @@ -0,0 +1,59 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +/** + * @author Per Bothner + * @date October 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + * Includes JDK 1.2 methods. + */ + +public class ParsePosition +{ + int index; + int errorIndex; + + public ParsePosition (int index) + { + this.index = index; + errorIndex = -1; + } + + public int getIndex () + { + return index; + } + + public void setIndex (int index) + { + this.index = index; + } + + public int getErrorIndex () + { + return errorIndex; + } + + public void setErrorIndex (int ei) + { + errorIndex = ei; + } + + public boolean equals (Object obj) + { + if (obj != null || ! (obj instanceof ParsePosition)) + return false; + ParsePosition other = (ParsePosition) obj; + return index == other.index && errorIndex == other.errorIndex; + } +} diff --git a/libjava/java/text/SimpleDateFormat.java b/libjava/java/text/SimpleDateFormat.java new file mode 100644 index 00000000000..b4012479045 --- /dev/null +++ b/libjava/java/text/SimpleDateFormat.java @@ -0,0 +1,522 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +import java.util.*; + +/** + * @author Per Bothner + * @date October 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: parse is not implemented. + */ + +public class SimpleDateFormat extends DateFormat +{ + private Date defaultCenturyStart; + private DateFormatSymbols formatData; + private String pattern; + + public SimpleDateFormat () + { + this("dd/MM/yy HH:mm", Locale.getDefault()); + } + + public SimpleDateFormat (String pattern) + { + this(pattern, Locale.getDefault()); + } + + public SimpleDateFormat (String pattern, Locale locale) + { + this.pattern = pattern; + this.calendar = Calendar.getInstance(locale); + this.numberFormat = NumberFormat.getInstance(locale); + numberFormat.setGroupingUsed(false); + this.formatData = new DateFormatSymbols (locale); + } + + public SimpleDateFormat (String pattern, DateFormatSymbols formatData) + { + this.pattern = pattern; + this.formatData = formatData; + this.calendar = Calendar.getInstance(); + this.numberFormat = NumberFormat.getInstance(); + numberFormat.setGroupingUsed(false); + } + + public Date get2DigitYearStart() + { + return defaultCenturyStart; + } + + public void set2DigitYearStart(Date startDate) + { + defaultCenturyStart = startDate; + } + + public DateFormatSymbols getDateFormatSymbols () + { + return formatData; + } + + public void setDateFormatSymbols (DateFormatSymbols value) + { + formatData = value; + } + + public String toPattern () + { + return pattern; + } + + public void applyPattern (String pattern) + { + this.pattern = pattern; + } + + private String applyLocalizedPattern (String pattern, + String oldChars, String newChars) + { + int len = pattern.length(); + StringBuffer buf = new StringBuffer(len); + boolean quoted = false; + for (int i = 0; i < len; i++) + { + char ch = pattern.charAt(i); + if (ch == '\'') + quoted = ! quoted; + if (! quoted) + { + int j = oldChars.indexOf(ch); + if (j >= 0) + ch = newChars.charAt(j); + } + buf.append(ch); + } + return buf.toString(); + } + + public void applyLocalizedPattern (String pattern) + { + String localChars = formatData.getLocalPatternChars(); + String standardChars = DateFormatSymbols.localPatternCharsDefault; + pattern = applyLocalizedPattern (pattern, localChars, standardChars); + applyPattern(pattern); + } + + public String toLocalizedPattern () + { + String localChars = formatData.getLocalPatternChars(); + String standardChars = DateFormatSymbols.localPatternCharsDefault; + return applyLocalizedPattern (pattern, standardChars, localChars); + } + + private final void append (StringBuffer buf, int value, int numDigits) + { + numberFormat.setMinimumIntegerDigits(numDigits); + numberFormat.format(value, buf, null); + } + + public StringBuffer format (Date date, StringBuffer buf, FieldPosition pos) + { + Calendar calendar = (Calendar) this.calendar.clone(); + calendar.setTime(date); + int len = pattern.length(); + int quoteStart = -1; + for (int i = 0; i < len; i++) + { + char ch = pattern.charAt(i); + if (ch == '\'') + { + // We must do a little lookahead to see if we have two + // single quotes embedded in quoted text. + if (i < len - 1 && pattern.charAt(i + 1) == '\'') + { + ++i; + buf.append(ch); + } + else + quoteStart = quoteStart < 0 ? i : -1; + } + // From JCL: any characters in the pattern that are not in + // the ranges of [a..z] and [A..Z] are treated as quoted + // text. + else if (quoteStart != -1 + || ((ch < 'a' || ch > 'z') + && (ch < 'A' || ch > 'Z'))) + buf.append(ch); + else + { + int first = i; + int value; + while (++i < len && pattern.charAt(i) == ch) ; + int count = i - first; // Number of repetions of ch in pattern. + int beginIndex = buf.length(); + int field; + i--; // Skip all but last instance of ch in pattern. + switch (ch) + { + case 'd': + append(buf, calendar.get(Calendar.DATE), count); + field = DateFormat.DATE_FIELD; + break; + case 'D': + append(buf, calendar.get(Calendar.DAY_OF_YEAR), count); + field = DateFormat.DAY_OF_YEAR_FIELD; + break; + case 'F': + append(buf, calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH),count); + field = DateFormat.DAY_OF_WEEK_IN_MONTH_FIELD; + break; + case 'E': + value = calendar.get(calendar.DAY_OF_WEEK); + buf.append(count <= 3 ? formatData.getShortWeekdays()[value] + : formatData.getWeekdays()[value]); + field = DateFormat.DAY_OF_WEEK_FIELD; + break; + case 'w': + append(buf, calendar.get(Calendar.WEEK_OF_YEAR), count); + field = DateFormat.WEEK_OF_YEAR_FIELD; + break; + case 'W': + append(buf, calendar.get(Calendar.WEEK_OF_MONTH), count); + field = DateFormat.WEEK_OF_MONTH_FIELD; + break; + case 'M': + value = calendar.get(Calendar.MONTH); + if (count <= 2) + append(buf, value + 1, count); + else + buf.append(count <= 3 ? formatData.getShortMonths()[value] + : formatData.getMonths()[value]); + field = DateFormat.MONTH_FIELD; + break; + case 'y': + value = calendar.get(Calendar.YEAR); + append(buf, count <= 2 ? value % 100 : value, count); + field = DateFormat.YEAR_FIELD; + break; + case 'K': + append(buf, calendar.get(Calendar.HOUR), count); + field = DateFormat.HOUR0_FIELD; + break; + case 'h': + value = ((calendar.get(Calendar.HOUR) + 11) % 12) + 1; + append(buf, value, count); + field = DateFormat.HOUR1_FIELD; + break; + case 'H': + append(buf, calendar.get(Calendar.HOUR_OF_DAY), count); + field = DateFormat.HOUR_OF_DAY0_FIELD; + break; + case 'k': + value = ((calendar.get(Calendar.HOUR_OF_DAY) + 23) % 24) + 1; + append(buf, value, count); + field = DateFormat.HOUR_OF_DAY1_FIELD; + break; + case 'm': + append(buf, calendar.get(Calendar.MINUTE), count); + field = DateFormat.MINUTE_FIELD; + break; + case 's': + append(buf, calendar.get(Calendar.SECOND), count); + field = DateFormat.SECOND_FIELD; + break; + case 'S': + append(buf, calendar.get(Calendar.MILLISECOND), count); + field = DateFormat.MILLISECOND_FIELD; + break; + case 'a': + value = calendar.get(calendar.AM_PM); + buf.append(formatData.getAmPmStrings()[value]); + field = DateFormat.AM_PM_FIELD; + break; + case 'z': + String zoneID = calendar.getTimeZone().getID(); + String[][] zoneStrings = formatData.getZoneStrings(); + int zoneCount = zoneStrings.length; + for (int j = 0; j < zoneCount; j++) + { + String[] strings = zoneStrings[j]; + if (zoneID.equals(strings[0])) + { + j = count > 3 ? 2 : 1; + if (calendar.get(Calendar.DST_OFFSET) != 0) + j+=2; + zoneID = strings[j]; + break; + } + } + buf.append(zoneID); + field = DateFormat.TIMEZONE_FIELD; + break; + default: + // Note that the JCL is actually somewhat + // contradictory here. It defines the pattern letters + // to be a particular list, but also says that a + // pattern containing an invalid pattern letter must + // throw an exception. It doesn't describe what an + // invalid pattern letter might be, so we just assume + // it is any letter in [a-zA-Z] not explicitly covered + // above. + throw new RuntimeException("bad format string"); + } + if (pos != null && field == pos.getField()) + { + pos.setBeginIndex(beginIndex); + pos.setEndIndex(buf.length()); + } + } + } + return buf; + } + + private final boolean expect (String source, ParsePosition pos, + char ch) + { + int x = pos.getIndex(); + boolean r = x < source.length() && source.charAt(x) == ch; + if (r) + pos.setIndex(x + 1); + else + pos.setErrorIndex(x); + return r; + } + + public Date parse (String source, ParsePosition pos) + { + int fmt_index = 0; + int fmt_max = pattern.length(); + + calendar.clear(); + int quote_start = -1; + for (; fmt_index < fmt_max; ++fmt_index) + { + char ch = pattern.charAt(fmt_index); + if (ch == '\'') + { + int index = pos.getIndex(); + if (fmt_index < fmt_max - 1 + && pattern.charAt(fmt_index + 1) == '\'') + { + if (! expect (source, pos, ch)) + return null; + ++fmt_index; + } + else + quote_start = quote_start < 0 ? fmt_index : -1; + continue; + } + + if (quote_start != -1 + || ((ch < 'a' || ch > 'z') + && (ch < 'A' || ch > 'Z'))) + { + if (! expect (source, pos, ch)) + return null; + continue; + } + + // We've arrived at a potential pattern character in the + // pattern. + int first = fmt_index; + while (++fmt_index < fmt_max && pattern.charAt(fmt_index) == ch) + ; + int count = fmt_index - first; + --fmt_index; + + // We can handle most fields automatically: most either are + // numeric or are looked up in a string vector. In some cases + // we need an offset. When numeric, `offset' is added to the + // resulting value. When doing a string lookup, offset is the + // initial index into the string array. + int calendar_field; + boolean is_numeric = true; + String[] match = null; + int offset = 0; + int zone_number = 0; + switch (ch) + { + case 'd': + calendar_field = Calendar.DATE; + break; + case 'D': + calendar_field = Calendar.DAY_OF_YEAR; + break; + case 'F': + calendar_field = Calendar.DAY_OF_WEEK_IN_MONTH; + break; + case 'E': + is_numeric = false; + offset = 1; + calendar_field = Calendar.DAY_OF_WEEK; + match = (count <= 3 + ? formatData.getShortWeekdays() + : formatData.getWeekdays()); + break; + case 'w': + calendar_field = Calendar.WEEK_OF_YEAR; + break; + case 'W': + calendar_field = Calendar.WEEK_OF_MONTH; + break; + case 'M': + calendar_field = Calendar.MONTH; + if (count <= 2) + ; + else + { + is_numeric = false; + match = (count <= 3 + ? formatData.getShortMonths() + : formatData.getMonths()); + } + break; + case 'y': + calendar_field = Calendar.YEAR; + if (count <= 2) + offset = 1900; + break; + case 'K': + calendar_field = Calendar.HOUR; + break; + case 'h': + calendar_field = Calendar.HOUR; + offset = -1; + break; + case 'H': + calendar_field = Calendar.HOUR_OF_DAY; + break; + case 'k': + calendar_field = Calendar.HOUR_OF_DAY; + offset = -1; + break; + case 'm': + calendar_field = Calendar.MINUTE; + break; + case 's': + calendar_field = Calendar.SECOND; + break; + case 'S': + calendar_field = Calendar.MILLISECOND; + break; + case 'a': + is_numeric = false; + calendar_field = Calendar.AM_PM; + match = formatData.getAmPmStrings(); + break; + case 'z': + // We need a special case for the timezone, because it + // uses a different data structure than the other cases. + is_numeric = false; + calendar_field = Calendar.DST_OFFSET; + String[][] zoneStrings = formatData.getZoneStrings(); + int zoneCount = zoneStrings.length; + int index = pos.getIndex(); + boolean found_zone = false; + for (int j = 0; j < zoneCount; j++) + { + String[] strings = zoneStrings[j]; + int k; + for (k = 1; k < strings.length; ++k) + { + if (source.startsWith(strings[k], index)) + break; + } + if (k != strings.length) + { + if (k > 2) + ; // FIXME: dst. + zone_number = 0; // FIXME: dst. + // FIXME: raw offset to SimpleTimeZone const. + calendar.setTimeZone(new SimpleTimeZone (1, strings[0])); + pos.setIndex(index + strings[k].length()); + break; + } + } + if (! found_zone) + { + pos.setErrorIndex(pos.getIndex()); + return null; + } + break; + default: + pos.setErrorIndex(pos.getIndex()); + return null; + } + + // Compute the value we should assign to the field. + int value; + if (is_numeric) + { + numberFormat.setMinimumIntegerDigits(count); + Number n = numberFormat.parse(source, pos); + if (pos == null || ! (n instanceof Long)) + return null; + value = n.intValue() + offset; + } + else if (match != null) + { + int index = pos.getIndex(); + int i; + for (i = offset; i < match.length; ++i) + { + if (source.startsWith(match[i], index)) + break; + } + if (i == match.length) + { + pos.setErrorIndex(index); + return null; + } + pos.setIndex(index + match[i].length()); + value = i; + } + else + value = zone_number; + + // Assign the value and move on. + try + { + calendar.set(calendar_field, value); + } + // FIXME: what exception is thrown on an invalid + // non-lenient set? + catch (IllegalArgumentException x) + { + pos.setErrorIndex(pos.getIndex()); + return null; + } + } + + return calendar.getTime(); + } + + public boolean equals (Object obj) + { + if (! (obj instanceof SimpleDateFormat) || ! super.equals(obj) ) + return false; + SimpleDateFormat other = (SimpleDateFormat) obj; + return (DateFormatSymbols.equals(pattern, other.pattern) + && DateFormatSymbols.equals(formatData, other.formatData) + && DateFormatSymbols.equals(defaultCenturyStart, + other.defaultCenturyStart)); + } + + public int hashCode () + { + int hash = super.hashCode(); + if (pattern != null) + hash ^= pattern.hashCode(); + return hash; + } +} diff --git a/libjava/java/text/StringCharacterIterator.java b/libjava/java/text/StringCharacterIterator.java new file mode 100644 index 00000000000..6eaa8e71cee --- /dev/null +++ b/libjava/java/text/StringCharacterIterator.java @@ -0,0 +1,142 @@ +// StringCharacterIterator.java - Iterate over string of Unicode characters. + +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.text; + +/** + * @author Tom Tromey + * @date February 22, 1999 + */ +/* Written using "Java Class Libraries", 2nd edition, plus online + * API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct to 1.1. + */ + +public final class StringCharacterIterator implements CharacterIterator +{ + public Object clone () + { + return (Object) new StringCharacterIterator (text, begin, end, pos); + } + + public char current () + { + // This follows JDK 1.2 semantics and not 1.1 semantics. + // In 1.1 we would throw an exception if begin==end. + return (pos < end) ? text.charAt(pos) : CharacterIterator.DONE; + } + + public boolean equals (Object obj) + { + if (! (obj instanceof StringCharacterIterator)) + return false; + StringCharacterIterator sci = (StringCharacterIterator) obj; + // The spec says "the same text". We take this to mean equals, + // not ==. + return (pos == sci.pos + && begin == sci.begin + && end == sci.end + && text.equals(sci.text)); + } + + public char first () + { + pos = begin; + return current (); + } + + public int getBeginIndex () + { + return begin; + } + + public int getEndIndex () + { + return end; + } + + public int getIndex () + { + return pos; + } + + public int hashCode () + { + // FIXME: this is a terrible hash code. Find a better one. + return text.hashCode() + pos + begin + end; + } + + public char last () + { + pos = end; + return current (); + } + + public char next () + { + if (pos == end) + return CharacterIterator.DONE; + ++pos; + return current (); + } + + public char previous () + { + if (pos == begin) + return CharacterIterator.DONE; + --pos; + return current (); + } + + public char setIndex (int idx) + { + // In 1.1 we would throw an error if `idx == end'. + if (idx < begin || idx > end) + throw new IllegalArgumentException (); + pos = idx; + return current (); + } + + public StringCharacterIterator (String text) + { + // FIXME: remove check for null once we have compiler/runtime + // support for NullPointerException. + this (text, 0, text == null ? 0 : text.length(), 0); + } + public StringCharacterIterator (String text, int pos) + { + // FIXME: remove check for null once we have compiler/runtime + // support for NullPointerException. + this (text, 0, text == null ? 0 : text.length(), pos); + } + public StringCharacterIterator (String text, int begin, int end, int pos) + { + if (text == null) + throw new NullPointerException (); + if (begin < 0 || begin > end || end > text.length() + // In 1.1 we would also throw if `pos == end'. + || pos < begin || pos > end) + throw new IllegalArgumentException (); + + this.text = text; + this.begin = begin; + this.end = end; + this.pos = pos; + } + + // String to iterate over. + private String text; + // Current position. + private int pos; + // Start position in string. + private int begin; + // End position in string. + private int end; +} diff --git a/libjava/java/util/BitSet.java b/libjava/java/util/BitSet.java new file mode 100644 index 00000000000..e5886951714 --- /dev/null +++ b/libjava/java/util/BitSet.java @@ -0,0 +1,183 @@ +// BitSet - A vector of bits. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; +import java.io.Serializable; + +/** + * @author Tom Tromey + * @date October 23, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * hashCode algorithm taken from JDK 1.2 docs. + */ + +public final class BitSet implements Cloneable, Serializable +{ + public void and (BitSet bs) + { + if (bs == null) + throw new NullPointerException (); + int max = Math.min(bits.length, bs.bits.length); + int i; + for (i = 0; i < max; ++i) + bits[i] &= bs.bits[i]; + for ( ; i < bits.length; ++i) + bits[i] = 0; + } + + public BitSet () + { + this (64); + } + + public BitSet (int nbits) + { + if (nbits < 0) + throw new NegativeArraySizeException (); + int length = nbits / 64; + if (nbits % 64 != 0) + ++length; + bits = new long[length]; + } + + public void clear (int pos) + { + if (pos < 0) + throw new IndexOutOfBoundsException (); + int bit = pos % 64; + int offset = pos / 64; + ensure (offset); + bits[offset] &= ~ (1 << bit); + } + + public Object clone () + { + BitSet bs = new BitSet (bits.length * 64); + System.arraycopy(bits, 0, bs.bits, 0, bits.length); + return bs; + } + + public boolean equals (Object obj) + { + if (! (obj instanceof BitSet)) + return false; + BitSet bs = (BitSet) obj; + int max = Math.min(bits.length, bs.bits.length); + int i; + for (i = 0; i < max; ++i) + if (bits[i] != bs.bits[i]) + return false; + // If one is larger, check to make sure all extra bits are 0. + for (int j = i; j < bits.length; ++j) + if (bits[j] != 0) + return false; + for (int j = i; j < bs.bits.length; ++j) + if (bs.bits[j] != 0) + return false; + return true; + } + + public boolean get (int pos) + { + if (pos < 0) + throw new IndexOutOfBoundsException (); + + int bit = pos % 64; + int offset = pos / 64; + + if (offset >= bits.length) + return false; + + return (bits[offset] & (1 << bit)) == 0 ? false : true; + } + + public int hashCode () + { + long h = 1234; + for (int i = bits.length - 1; i >= 0; --i) + h ^= bits[i] * (i + 1); + return (int) ((h >> 32) ^ h); + } + + public void or (BitSet bs) + { + if (bs == null) + throw new NullPointerException (); + ensure (bs.bits.length - 1); + int i; + for (i = 0; i < bs.bits.length; ++i) + bits[i] |= bs.bits[i]; + } + + public void set (int pos) + { + if (pos < 0) + throw new IndexOutOfBoundsException (); + int bit = pos % 64; + int offset = pos / 64; + ensure (offset); + bits[offset] |= 1 << bit; + } + + public int size () + { + return bits.length * 64; + } + + public String toString () + { + StringBuffer result = new StringBuffer ("{"); + boolean first = true; + for (int i = 0; i < bits.length; ++i) + { + int bit = 1; + long word = bits[i]; + for (int j = 0; j < 64; ++j) + { + if ((word & bit) != 0) + { + if (! first) + result.append(", "); + result.append(64 * i + j); + first = false; + } + bit <<= 1; + } + } + + return result.append("}").toString(); + } + + public void xor (BitSet bs) + { + if (bs == null) + throw new NullPointerException (); + ensure (bs.bits.length - 1); + int i; + for (i = 0; i < bs.bits.length; ++i) + bits[i] ^= bs.bits[i]; + } + + // Make sure the vector is big enough. + private final void ensure (int lastElt) + { + if (lastElt + 1 > bits.length) + { + long[] nd = new long[lastElt + 1]; + System.arraycopy(bits, 0, nd, 0, bits.length); + bits = nd; + } + } + + // The actual bits. + private long[] bits; +} diff --git a/libjava/java/util/Calendar.java b/libjava/java/util/Calendar.java new file mode 100644 index 00000000000..8649adf600d --- /dev/null +++ b/libjava/java/util/Calendar.java @@ -0,0 +1,258 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Per Bothner + * @date October 24, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3, + * and "The Java Language Specification", ISBN 0-201-63451-1. + * Status: Unimplemented: getAvailableLocales. + * No Locale knowledge. + */ + +public abstract class Calendar implements java.io.Serializable, Cloneable +{ + public final static int JANUARY = 0; + public final static int FEBRUARY = 1; + public final static int MARCH = 2; + public final static int APRIL = 3; + public final static int MAY = 4; + public final static int JUNE = 5; + public final static int JULY = 6; + public final static int AUGUST = 7; + public final static int SEPTEMBER = 8; + public final static int OCTOBER = 9; + public final static int NOVEMBER = 10; + public final static int DECEMBER = 11; + public final static int UNDECIMBER = 12; + + public final static int SUNDAY = 1; + public final static int MONDAY = 2; + public final static int TUESDAY = 3; + public final static int WEDNESDAY = 4; + public final static int THURSDAY = 5; + public final static int FRIDAY = 6; + public final static int SATURDAY = 7; + + public final static int AM = 0; + public final static int PM = 1; + + public final static int FIELD_COUNT = 17; + + // These constants are not docuemnted, but were determined using + // a simple test program. + public final static int ERA = 0; + public final static int YEAR = 1; + public final static int MONTH = 2; + public final static int WEEK_OF_YEAR = 3; + public final static int WEEK_OF_MONTH = 4; + public final static int DATE = 5; + public final static int DAY_OF_MONTH = 5; + public final static int DAY_OF_YEAR = 6; + public final static int DAY_OF_WEEK = 7; + public final static int DAY_OF_WEEK_IN_MONTH = 8; + public final static int AM_PM = 9; + public final static int HOUR = 10; + public final static int HOUR_OF_DAY = 11; + public final static int MINUTE = 12; + public final static int SECOND = 13; + public final static int MILLISECOND = 14; + public final static int ZONE_OFFSET = 15; + public final static int DST_OFFSET = 16; + + // The fields are as specified in Sun's "Serialized Form" + // in the JDK 1.2 beta 4 API specification. + protected boolean areFieldsSet; + protected int[] fields; + private int firstDayOfWeek; + protected boolean[] isSet; + protected boolean isTimeSet; + private boolean lenient; + private int minimalDaysInFirstWeek; + private int nextStamp; + //private int serialVersionOnStream; + protected long time; + private TimeZone zone; + + protected Calendar () + { + this (null, null); + } + + protected Calendar (TimeZone tx, Locale loc) + { + fields = new int[FIELD_COUNT]; + isSet = new boolean[FIELD_COUNT]; + firstDayOfWeek = SUNDAY; // Locale-dependent. FIXME. + this.zone = zone != null ? zone : TimeZone.getDefault(); + } + + public Object clone () + { + try + { + return super.clone(); + } + catch (CloneNotSupportedException ex) + { + throw new RuntimeException("internal error - "+ex); + } + } + + public static Calendar getInstance () + { + return new GregorianCalendar (); + } + + public static Calendar getInstance (TimeZone zone) + { + return new GregorianCalendar (zone); + } + + public static Calendar getInstance (Locale locale) + { + return new GregorianCalendar (locale); + } + + public static Calendar getInstance (TimeZone zone, Locale locale) + { + return new GregorianCalendar (zone, locale); + } + + public boolean isLenient() { return lenient; } + public void setLenient (boolean lenient) { this.lenient = lenient; } + + public int getFirstDayOfWeek () + { + return firstDayOfWeek; + } + + public void setFirstDayOfWeek (int value) + { + firstDayOfWeek = value; + } + + public int getMinimalDaysInFirstWeek () + { + return minimalDaysInFirstWeek; + } + + public void setMinimalDaysInFirstWeek (int value) + { + minimalDaysInFirstWeek = value; + } + + public TimeZone getTimeZone () + { + return zone; + } + + public void setTimeZone (TimeZone tz) + { + zone = tz; + } + + abstract public void add(int fld, int amount); + abstract public void roll (int fld, boolean up); + + public final void set (int year, int month, int date) + { + set(YEAR, year); + set(MONTH, month); + set(DATE, date); + } + + public final void set (int year, int month, int date, int hour, int minute) + { + set(year, month, date); + set(HOUR_OF_DAY, hour); + set(MINUTE, minute); + } + + public final void set (int year, int month, int date, + int hour, int minute, int second) + { + set(year, month, date, hour, minute); + set(SECOND, second); + } + + public final void set (int fld, int value) + { + fields[fld] = value; + isTimeSet = false; + } + + public final void clear (int fld) + { + fields[fld] = 0; + isSet[fld] = false; + areFieldsSet = false; + } + + public final void clear () + { + for (int fld = FIELD_COUNT; --fld >= 0; ) + { + fields[fld] = 0; + isSet[fld] = false; + } + areFieldsSet = false; + } + + protected void complete() + { + if (!isTimeSet) computeTime(); + if (!areFieldsSet) computeFields(); + } + + protected abstract void computeFields(); + protected abstract void computeTime(); + + protected final int internalGet (int fld) { return fields[fld]; } + + public final int get(int fld) + { + complete(); + return fields[fld]; + } + + public abstract boolean after (Object cal); + public abstract boolean before (Object cal); + public abstract boolean equals (Object obj); + + protected long getTimeInMillis() + { + if (!isTimeSet) computeTime(); + return time; + } + + public final Date getTime() { return new Date(getTimeInMillis()); } + + public final void setTime (Date date) + { + setTimeInMillis(date.getTime()); + } + + protected void setTimeInMillis (long millis) + { + time = millis; + isTimeSet = true; + clear(); + } + + abstract public int getMaximum(int fld); + abstract public int getMinimum(int fld); + abstract public int getGreatestMinimum(int fld); + abstract public int getLeastMaximum(int fld); + + public final boolean isSet(int fld) { return isSet[fld]; } +} diff --git a/libjava/java/util/ConcurrentModificationException.java b/libjava/java/util/ConcurrentModificationException.java new file mode 100644 index 00000000000..478fdffebb7 --- /dev/null +++ b/libjava/java/util/ConcurrentModificationException.java @@ -0,0 +1,33 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date September 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +/* Added in JDK 1.2 */ +public class ConcurrentModificationException extends RuntimeException +{ + public ConcurrentModificationException() + { + super(); + } + + public ConcurrentModificationException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/util/Date.java b/libjava/java/util/Date.java new file mode 100644 index 00000000000..3d237804e4c --- /dev/null +++ b/libjava/java/util/Date.java @@ -0,0 +1,460 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; +import java.text.*; + +/** + * @author Per Bothner + * @date October 24, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3, + * "The Java Language Specification", ISBN 0-201-63451-1, + * and O'Reilly's "Java in a Nutshell". + * Status: Need to re-write toString(). + * Missing: ToGMTString and toLocaleString. + * Serialization spec: Specifies readObject/writeObject. + */ + +public class Date implements java.io.Serializable, Cloneable +{ + private long millis; + + public Date() { millis = System.currentTimeMillis(); } + + public Date(long millis) { this.millis = millis; } + + public Date(int year, int month, int date, int hours, + int minutes, int seconds) + { + setTime(year, month, date, hours, minutes, seconds); + } + + public Date(int year, int month, int date, int hours, int minutes) + { + setTime(year, month, date, hours, minutes, 0); + } + + public Date(int year, int month, int date) + { + setTime(year, month, date, 0, 0, 0); + } + + public Date (String s) { this(parse(s)); } + + private static int skipParens(String string, int offset) + { + int len = string.length(); + int p = 0; + int i; + + for (i = offset; i < len; ++i) + { + if (string.charAt(i) == '(') + ++p; + else if (string.charAt(i) == ')') + { + --p; + if (p == 0) + return i + 1; + // If we've encounted unbalanced parens, just return the + // leftover one as an ordinary character. It will be + // caught later in parsing and cause an + // IllegalArgumentException. + if (p < 0) + return i; + } + } + + // Not sure what to do if `p != 0' here. + return i; + } + + private static int parseTz(String tok, char sign) + throws IllegalArgumentException + { + int num; + + try + { + // parseInt doesn't handle '+' so strip off sign. + num = Integer.parseInt(tok.substring(1)); + } + catch (NumberFormatException ex) + { + throw new IllegalArgumentException(tok); + } + + // Convert hours to minutes. + if (num < 24) + num *= 60; + else + num = (num / 100) * 60 + num % 100; + + return sign == '-' ? -num : num; + } + + private static int parseMonth(String tok) + { + // Initialize strings for month names. + // We could possibly use the fields of DateFormatSymbols but that is + // localized and thus might not match the English words specified. + String months[] = { "JANUARY", "FEBRUARY", "MARCH", "APRIL", "MAY", + "JUNE", "JULY", "AUGUST", "SEPTEMBER", "OCTOBER", + "NOVEMBER", "DECEMBER" }; + + int i; + for (i = 0; i < 12; i++) + if (months[i].startsWith(tok)) + return i; + + // Return -1 if not found. + return -1; + } + + private static boolean parseDayOfWeek(String tok) + { + // Initialize strings for days of the week names. + // We could possibly use the fields of DateFormatSymbols but that is + // localized and thus might not match the English words specified. + String daysOfWeek[] = { "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", + "THURSDAY", "FRIDAY", "SATURDAY" }; + + int i; + for (i = 0; i < 7; i++) + if (daysOfWeek[i].startsWith(tok)) + return true; + + return false; + } + + public static long parse(String string) + { + // Initialize date/time fields before parsing begins. + int year = -1; + int month = -1; + int day = -1; + int hour = -1; + int minute = -1; + int second = -1; + int timezone = 0; + boolean localTimezone = true; + + // Trim out any nested stuff in parentheses now to make parsing easier. + StringBuffer buf = new StringBuffer(); + int off = 0; + int openParenOffset, tmpMonth; + while ((openParenOffset = string.indexOf('(', off)) >= 0) + { + // Copy part of string leading up to open paren. + buf.append(string.substring(off, openParenOffset)); + off = skipParens(string, openParenOffset); + } + buf.append(string.substring(off)); + + // Make all chars upper case to simplify comparisons later. + // Also ignore commas; treat them as delimiters. + StringTokenizer strtok = + new StringTokenizer(buf.toString().toUpperCase(), " \t\n\r,"); + + while (strtok.hasMoreTokens()) + { + String tok = strtok.nextToken(); + char firstch = tok.charAt(0); + if ((firstch == '+' || firstch == '-') && year >= 0) + { + timezone = parseTz(tok, firstch); + localTimezone = false; + } + else if (firstch >= '0' && firstch <= '9') + { + while (tok != null && tok.length() > 0) + { + // A colon or slash may be valid in the number. + // Find the first of these before calling parseInt. + int colon = tok.indexOf(':'); + int slash = tok.indexOf('/'); + int hyphen = tok.indexOf('-'); + // We choose tok.length initially because it makes + // processing simpler. + int punctOffset = tok.length(); + if (colon >= 0) + punctOffset = Math.min(punctOffset, colon); + if (slash >= 0) + punctOffset = Math.min(punctOffset, slash); + if (hyphen >= 0) + punctOffset = Math.min(punctOffset, hyphen); + // Following code relies on -1 being the exceptional + // case. + if (punctOffset == tok.length()) + punctOffset = -1; + + int num; + try + { + num = Integer.parseInt(punctOffset < 0 ? tok : + tok.substring(0, punctOffset)); + } + catch (NumberFormatException ex) + { + throw new IllegalArgumentException(tok); + } + + // TBD: Spec says year can be followed by a slash. That might + // make sense if using YY/MM/DD formats, but it would fail in + // that format for years <= 70. Also, what about 1900? That + // is interpreted as the year 3800; seems that the comparison + // should be num >= 1900 rather than just > 1900. + // What about a year of 62 - 70? (61 or less could be a (leap) + // second). 70/MM/DD cause an exception but 71/MM/DD is ok + // even though there's no ambiguity in either case. + // For the parse method, the spec as written seems too loose. + // Until shown otherwise, we'll follow the spec as written. + if (num > 70 && (punctOffset < 0 || punctOffset == slash)) + year = num > 1900 ? num - 1900 : num; + else if (punctOffset > 0 && punctOffset == colon) + { + if (hour < 0) + hour = num; + else + minute = num; + } + else if (punctOffset > 0 && punctOffset == slash) + { + if (month < 0) + month = num - 1; + else + day = num; + } + else if (hour >= 0 && minute < 0) + minute = num; + else if (minute >= 0 && second < 0) + second = num; + else if (day < 0) + day = num; + else + throw new IllegalArgumentException(tok); + + // Advance string if there's more to process in this token. + if (punctOffset < 0 || punctOffset + 1 >= tok.length()) + tok = null; + else + tok = tok.substring(punctOffset + 1); + } + } + else if (firstch >= 'A' && firstch <= 'Z') + { + if (tok.equals("AM")) + { + if (hour < 1 || hour > 12) + throw new IllegalArgumentException(tok); + if (hour == 12) + hour = 0; + } + else if (tok.equals("PM")) + { + if (hour < 1 || hour > 12) + throw new IllegalArgumentException(tok); + if (hour < 12) + hour += 12; + } + else if (parseDayOfWeek(tok)) + ; // Ignore it; throw the token away. + else if (tok.equals("UT") || tok.equals("UTC") || tok.equals("GMT")) + localTimezone = false; + else if (tok.startsWith("UT") || tok.startsWith("GMT")) + { + int signOffset = 3; + if (tok.charAt(1) == 'T' && tok.charAt(2) != 'C') + signOffset = 2; + + char sign = tok.charAt(signOffset); + if (sign != '+' && sign != '-') + throw new IllegalArgumentException(tok); + + timezone = parseTz(tok.substring(signOffset), sign); + localTimezone = false; + } + else if ((tmpMonth = parseMonth(tok)) >= 0) + month = tmpMonth; + else if (tok.length() == 3 && tok.charAt(2) == 'T') + { + // Convert timezone offset from hours to minutes. + char ch = tok.charAt(0); + if (ch == 'E') + timezone = -5 * 60; + else if (ch == 'C') + timezone = -6 * 60; + else if (ch == 'M') + timezone = -7 * 60; + else if (ch == 'P') + timezone = -8 * 60; + else + throw new IllegalArgumentException(tok); + + // Shift 60 minutes for Daylight Savings Time. + if (tok.charAt(1) == 'D') + timezone += 60; + else if (tok.charAt(1) != 'S') + throw new IllegalArgumentException(tok); + + localTimezone = false; + } + else + throw new IllegalArgumentException(tok); + } + else + throw new IllegalArgumentException(tok); + } + + // Unspecified minutes and seconds should default to 0. + if (minute < 0) + minute = 0; + if (second < 0) + second = 0; + + // Throw exception if any other fields have not been recognized and set. + if (year < 0 || month < 0 || day < 0 || hour < 0) + throw new IllegalArgumentException("Missing field"); + + // Return the time in either local time or relative to GMT as parsed. + // If no time-zone was specified, get the local one (in minutes) and + // convert to milliseconds before adding to the UTC. + return UTC(year, month, day, hour, minute, second) + (localTimezone ? + new Date(year, month, day).getTimezoneOffset() * 60 * 1000: + -timezone * 60 * 1000); + } + + public boolean after (Date when) { return this.millis > when.millis; } + public boolean before (Date when) { return this.millis < when.millis; } + + public boolean equals(Object obj) + { + return (obj != null && obj instanceof Date + && ((Date)obj).millis == this.millis); + } + + public long getTime() { return millis; } + + public int hashCode() + { + return (int)(millis^(millis>>>32)); + } + + private void setTime(int year, int month, int date, + int hours, int minutes, int seconds) + { + Calendar cal = new GregorianCalendar(year+1900, month, date, + hours, minutes, seconds); + millis = cal.getTimeInMillis(); + } + + public void setTime(long millis) { this.millis = millis; } + + private int getField (int fld) + { + Calendar cal = new GregorianCalendar(); + cal.setTime(this); + return cal.get(fld); + } + + public int getYear () + { + return getField(Calendar.YEAR) - 1900; + } + + public int getMonth () + { + return getField(Calendar.MONTH); + } + + public int getDate () + { + return getField(Calendar.DATE); + } + + public int getDay () + { + return getField(Calendar.DAY_OF_WEEK) - 1; + } + + public int getHours () + { + return getField(Calendar.HOUR_OF_DAY); + } + + public int getMinutes () + { + return getField(Calendar.MINUTE); + } + + public int getSeconds () + { + return getField(Calendar.SECOND); + } + + private void setField (int fld, int value) + { + Calendar cal = new GregorianCalendar(); + cal.setTime(this); + cal.set(fld, value); + millis = cal.getTimeInMillis(); + } + + public void setYear (int year) + { + setField(Calendar.YEAR, 1900 + year); + } + + public void setMonth (int month) + { + setField(Calendar.MONTH, month); + } + + public void setDate (int date) + { + setField(Calendar.DATE, date); + } + + public void setHours (int hours) + { + setField(Calendar.HOUR_OF_DAY, hours); + } + + public void setMinutes (int minutes) + { + setField(Calendar.MINUTE, minutes); + } + + public void setSeconds (int seconds) + { + setField(Calendar.SECOND, seconds); + } + + public int getTimezoneOffset () + { + Calendar cal = new GregorianCalendar(); + cal.setTime(this); + return - (cal.get(Calendar.ZONE_OFFSET) + + cal.get(Calendar.DST_OFFSET)/(60*1000)); + } + + public native String toString (); + + // TODO: toLocaleString + // TODO: toGMTString + + public static long UTC (int year, int month, int date, + int hours, int minutes, int seconds) + { + GregorianCalendar cal = new GregorianCalendar (TimeZone.zoneGMT); + cal.set(year+1900, month, date, hours, minutes, seconds); + return cal.getTimeInMillis(); + } +} diff --git a/libjava/java/util/Dictionary.java b/libjava/java/util/Dictionary.java new file mode 100644 index 00000000000..2c27112106d --- /dev/null +++ b/libjava/java/util/Dictionary.java @@ -0,0 +1,34 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date August 31, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +/* The JDK 1.2 beta doc indicates that Dictionary is obsolete and that the + * new java.util.Map interface should be used instead. + */ +public abstract class Dictionary +{ + public abstract Enumeration elements(); + public abstract Object get(Object key) throws NullPointerException; + public abstract boolean isEmpty(); + public abstract Enumeration keys(); + public abstract Object put(Object key, Object elem) + throws NullPointerException; + public abstract Object remove(Object key) throws NullPointerException; + public abstract int size(); +} diff --git a/libjava/java/util/EmptyStackException.java b/libjava/java/util/EmptyStackException.java new file mode 100644 index 00000000000..9c4c0b0b4f8 --- /dev/null +++ b/libjava/java/util/EmptyStackException.java @@ -0,0 +1,27 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date September 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class EmptyStackException extends RuntimeException +{ + public EmptyStackException() + { + super(); + } +} diff --git a/libjava/java/util/Enumeration.java b/libjava/java/util/Enumeration.java new file mode 100644 index 00000000000..233288843e0 --- /dev/null +++ b/libjava/java/util/Enumeration.java @@ -0,0 +1,24 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date August 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1. + * Status: Believed complete and correct + */ + +public interface Enumeration +{ + public boolean hasMoreElements(); + public Object nextElement() throws NoSuchElementException; +} diff --git a/libjava/java/util/EventListener.java b/libjava/java/util/EventListener.java new file mode 100644 index 00000000000..394d98c28ff --- /dev/null +++ b/libjava/java/util/EventListener.java @@ -0,0 +1,24 @@ +// EventListener.java - Listen for events from event source. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Tom Tromey + * @date December 12, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Believed complete and correct. + */ + +public interface EventListener +{ +} diff --git a/libjava/java/util/EventObject.java b/libjava/java/util/EventObject.java new file mode 100644 index 00000000000..178ecff3e79 --- /dev/null +++ b/libjava/java/util/EventObject.java @@ -0,0 +1,42 @@ +// EventObject.java - Represent events fired by objects. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Tom Tromey + * @date December 12, 1998 + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * Status: Believed complete, but not fully correct. + */ + +public class EventObject implements java.io.Serializable +{ + public EventObject (Object source) + { + this.source = source; + } + + public Object getSource () + { + return source; + } + + public String toString () + { + // FIXME. + return getSource().toString(); + } + + // Source of the event. + protected transient Object source; +} diff --git a/libjava/java/util/GregorianCalendar.java b/libjava/java/util/GregorianCalendar.java new file mode 100644 index 00000000000..d20c06ef825 --- /dev/null +++ b/libjava/java/util/GregorianCalendar.java @@ -0,0 +1,257 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Per Bothner + * @date October 24, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3, + * and "The Java Language Specification", ISBN 0-201-63451-1. + * Status: "leniency" is not handled, and neither is roll-over in + * add and roll. This is partly because of unclear specification. + * hashCode has no spec. + */ + +public class GregorianCalendar extends Calendar { + public static final int BC = 0; + public static final int AD = 1; + + // The fields are as specified in Sun's "Serialized Form" + // in the JDK 1.2 beta 4 API specification. + // Value from a simple test program (getGregorianChange.getTime()). + long gregorianCutover = -12219292800000L; + + private final static int[] mins = { + 0 /* ERA */, + 1 /* YEAR */, + 0 /* MONTH */, + 0 /* WEEK_OF_YEAR */, + 0 /* WEEK_OF_MONTH */, + 1 /* DATE */, + 1 /* DAY_OF_YEAR */, + 1 /* DAY_OF_WEEK */, + -1 /* DAY_OF_WEEK_IN_MONTH */, + 0 /* AM_PM */, + 0 /* HOUR */, + 0 /* HOUR_OF_DAY */, + 0 /* MINUTE */, + 0 /* SECOND */, + 0 /* MILLISECOND */, + -43200000 /* ZONE_OFFSET */, + 0 /* DST_OFFSET */ + }; + + private final static int[] maxs = { + 1 /* ERA */, + 5000000 /* YEAR */, + 11 /* MONTH */, + 54 /* WEEK_OF_YEAR */, + 6 /* WEEK_OF_MONTH */, + 31 /* DATE */, + 366 /* DAY_OF_YEAR */, + 7 /* DAY_OF_WEEK */, + 6 /* DAY_OF_WEEK_IN_MONTH */, + 1 /* AM_PM */, + 12 /* HOUR */, + 23 /* HOUR_OF_DAY */, + 59 /* MINUTE */, + 59 /* SECOND */, + 999 /* MILLISECOND */, + 43200000 /* ZONE_OFFSET */, + 3600000 /* DST_OFFSET */ + }; + + private final static int[] leastMaximums = { + 1 /* ERA */, + 5000000 /* YEAR */, + 11 /* MONTH */, + 53 /* WEEK_OF_YEAR */, + 6 /* WEEK_OF_MONTH */, + 28 /* DATE */, + 365 /* DAY_OF_YEAR */, + 7 /* DAY_OF_WEEK */, + 4 /* DAY_OF_WEEK_IN_MONTH */, + 1 /* AM_PM */, + 11 /* HOUR */, + 23 /* HOUR_OF_DAY */, + 59 /* MINUTE */, + 59 /* SECOND */, + 999 /* MILLISECOND */, + 43200000 /* ZONE_OFFSET */, + 3600000 /* DST_OFFSET */ + }; + + public GregorianCalendar () + { + this(null, null); + } + + public GregorianCalendar (TimeZone zone) + { + this (zone, null); + } + + public GregorianCalendar (Locale locale) + { + this (null, locale); + } + + public GregorianCalendar (TimeZone zone, Locale locale) + { + super (zone, locale); + } + + public GregorianCalendar (int year, int month, int date) + { + this((TimeZone) null); + set (year, month, date); + } + + public GregorianCalendar (int year, int month, int date, + int hour, int minute) + { + this((TimeZone) null); + set (year, month, date, hour, minute); + } + + public GregorianCalendar (int year, int month, int date, + int hour, int minute, int second) + { + this((TimeZone) null); + set (year, month, date, hour, minute, second); + } + + public int getMinimum(int calfield) { return mins[calfield]; } + public int getGreatestMinimum(int calfield) { return mins[calfield]; } + public int getMaximum(int calfield) { return maxs[calfield]; } + public int getLeastMaximum(int calfield) { return leastMaximums[calfield]; } + + protected native void computeFields(); + + protected native void computeTime(); + + public void add (int fld, int amount) + { + if (fld >= ZONE_OFFSET) + throw new IllegalArgumentException("bad field to add"); + fields[fld] += amount; + adjust(fld); + } + + public void roll (int fld, boolean up) + { + if (fld >= ZONE_OFFSET) + throw new IllegalArgumentException("bad field to roll"); + + int old = fields[fld]; + if (up) + { + fields[fld] = old == getMaximum(fld) ? getMinimum(fld) + : old + 1; + } + else + { + fields[fld] = old == getMinimum(fld) ? getMaximum(fld) + : old - 1; + } + } + + private void adjust (int fld) + { + int value = fields[fld]; + int radix = maxs[fld] + 1; + switch (fld) + { + case MONTH: + case SECOND: + case MILLISECOND: + if (value >= radix) + { + int next = value / radix; + fields[fld] = value - radix * next; + fields[fld - 1] += next; + adjust(fld - 1); + } + else if (value < 0) // min[fld] + { + int next = (value - radix - 1) / radix; + fields[fld] = value - radix * next; + fields[fld - 1] += next; + adjust(fld - 1); + } + break; + } + } + + public final Date getGregorianChange() { return new Date(gregorianCutover); } + public void setGregorianChange (Date date) + { gregorianCutover = date.getTime(); } + + public boolean isLeapYear(int year) + { + if ((year % 4) != 0) + return false; + if ((year % 100) != 0 || (year % 400) == 0) + return true; + // year divisible by 100 but not 400. + GregorianCalendar date = new GregorianCalendar(year, FEBRUARY, 28); + return gregorianCutover < date.getTimeInMillis(); + } + + public boolean after (Object cal) + { + return cal instanceof Calendar + && getTimeInMillis() > ((Calendar) cal).getTimeInMillis(); + } + + public boolean before (Object cal) + { + return cal instanceof Calendar + && getTimeInMillis() < ((Calendar) cal).getTimeInMillis(); + } + + public boolean equals (Object obj) + { + if (obj == null || ! (obj instanceof GregorianCalendar)) + return false; + GregorianCalendar other = (GregorianCalendar) obj; + + for (int i = FIELD_COUNT; --i >= 0; ) + { + boolean set = isSet[i]; + if (set != other.isSet[i] + || (set && fields[i] != other.fields[i])) + return false; + } + if (areFieldsSet != other.areFieldsSet + || isTimeSet != other.isTimeSet + || (isTimeSet && time != other.time) + || getFirstDayOfWeek() != other.getFirstDayOfWeek() + || getMinimalDaysInFirstWeek() != other.getMinimalDaysInFirstWeek() + || isLenient() != other.isLenient() + || ! getTimeZone().equals(other.getTimeZone())) + return false; + return true; + } + + public int hashCode () + { + int hashcode = 0; + for (int i = FIELD_COUNT; --i >= 0; ) + { + if (isSet[i]) + hashcode += 37 * fields[i]; + } + if (isTimeSet) + hashcode += 89 * time; + return hashcode; + } +} diff --git a/libjava/java/util/Hashtable.java b/libjava/java/util/Hashtable.java new file mode 100644 index 00000000000..51ab2b16ac3 --- /dev/null +++ b/libjava/java/util/Hashtable.java @@ -0,0 +1,398 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +import java.io.Serializable; + +/** + * @author Warren Levy + * @date September 24, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +class HashtableEntry +{ + public Object key; + public Object value; + public HashtableEntry nextEntry = null; + + public HashtableEntry(Object key, Object value) + { + this.key = key; + this.value = value; + } +} + +class HashtableEnumeration implements Enumeration +{ + // TBD: Enumeration is not safe if new elements are put in the table as + // this could cause a rehash and we'd completely lose our place. Even + // without a rehash, it is undetermined if a new element added would + // appear in the enumeration. The spec says nothing about this, but + // the "Java Class Libraries" book infers that modifications to the + // hashtable during enumeration causes indeterminate results. Don't do it! + // A safer way would be to make a copy of the table (e.g. into a vector) + // but this is a fair bit more expensive. + private HashtableEntry[] bucket; + private int bucketIndex; + private HashtableEntry elem; + private int enumCount; + private int size; + private boolean values; + + public HashtableEnumeration(HashtableEntry[] bkt, int sz, boolean isValues) + { + bucket = bkt; + bucketIndex = -1; + enumCount = 0; + elem = null; + size = sz; + values = isValues; + } + + public boolean hasMoreElements() + { + return enumCount < size; + } + + public Object nextElement() + { + if (!hasMoreElements()) + throw new NoSuchElementException(); + + // Find next element + if (elem != null) // In the middle of a bucket + elem = elem.nextEntry; + while (elem == null) // Find the next non-empty bucket + elem = bucket[++bucketIndex]; + + enumCount++; + return values ? elem.value : elem.key; + } +} + +// TBD: The algorithm used here closely reflects what is described in +// the "Java Class Libraries" book. The "Java Language Spec" is much +// less specific about the implementation. Because of this freedom +// provided by the actual spec, hash table algorithms should be +// investigated to see if there is a better alternative to this one. + +// TODO12: +// public class Hashtable extends Dictionary +// implements Map, Cloneable, Serializable + +public class Hashtable extends Dictionary implements Cloneable, Serializable +{ + private HashtableEntry bucket[]; + private float loadFactor; + private int hsize = 0; + + public Hashtable() + { + // The "Java Class Libraries" book (p. 919) says that initial size in this + // case is 101 (a prime number to increase the odds of even distribution). + this(101, 0.75F); + } + + public Hashtable(int initialSize) + { + this(initialSize, 0.75F); + } + + public Hashtable(int initialSize, float loadFactor) + { + if (initialSize < 0 || loadFactor <= 0.0 || loadFactor > 1.0) + throw new IllegalArgumentException(); + + bucket = new HashtableEntry[initialSize]; + this.loadFactor = loadFactor; + } + + // TODO12: + // public Hashtable(Map t) + // { + // } + + public synchronized void clear() + { + // Aid the GC by nulling out the entries in the hash table. + for (int i = 0; i < bucket.length; i++) + { + HashtableEntry elem = bucket[i]; + bucket[i] = null; // May already be null. + while (elem != null) + { + HashtableEntry next = elem.nextEntry; + elem.nextEntry = null; // May already be null. + elem = next; + } + } + hsize = 0; + } + + public synchronized Object clone() + { + // New hashtable will have same initialCapacity and loadFactor. + Hashtable newTable = new Hashtable(bucket.length, loadFactor); + + HashtableEntry newElem, prev = null; + for (int i = 0; i < bucket.length; i++) + for (HashtableEntry elem = bucket[i]; elem != null; elem = elem.nextEntry) + { + // An easy but expensive method is newTable.put(elem.key, elem.value); + // Since the hash tables are the same size, the buckets and collisions + // will be the same in the new one, so we can just clone directly. + // This is much cheaper than using put. + newElem = new HashtableEntry(elem.key, elem.value); + if (newTable.bucket[i] == null) + prev = newTable.bucket[i] = newElem; + else + prev = prev.nextEntry = newElem; + } + + newTable.hsize = this.hsize; + return newTable; + } + + public synchronized boolean contains(Object value) throws NullPointerException + { + // An exception is thrown here according to the JDK 1.2 doc. + if (value == null) + throw new NullPointerException(); + + for (int i = 0; i < bucket.length; i++) + for (HashtableEntry elem = bucket[i]; elem != null; elem = elem.nextEntry) + if (elem.value.equals(value)) + return true; + + return false; + } + + public synchronized boolean containsKey(Object key) + { + // The Map interface mandates that we throw this. + if (key == null) + throw new NullPointerException (); + + for (HashtableEntry elem = bucket[Math.abs(key.hashCode() + % bucket.length)]; + elem != null; elem = elem.nextEntry) + if (elem.key.equals(key)) + return true; + + return false; + } + + public synchronized Enumeration elements() + { + return new HashtableEnumeration(bucket, hsize, true); + } + + public synchronized Object get(Object key) + { + // The Dictionary interface mandates that get() throw a + // NullPointerException if key is null. + if (key == null) + throw new NullPointerException (); + + for (HashtableEntry elem = bucket[Math.abs (key.hashCode() + % bucket.length)]; + elem != null; elem = elem.nextEntry) + if (elem.key.equals(key)) + return elem.value; + + return null; + } + + public boolean isEmpty() + { + return this.hsize <= 0; + } + + public synchronized Enumeration keys() + { + return new HashtableEnumeration(bucket, hsize, false); + } + + public synchronized Object put(Object key, Object value) + throws NullPointerException + { + if (key == null || value == null) + throw new NullPointerException(); + + HashtableEntry prevElem = null; + final int index = Math.abs(key.hashCode() % bucket.length); + + for (HashtableEntry elem = bucket[index]; elem != null; + prevElem = elem, elem = elem.nextEntry) + if (elem.key.equals(key)) + { + // Update with the new value and then return the old one. + Object oldVal = elem.value; + elem.value = value; + return oldVal; + } + + // At this point, we know we need to add a new element. + HashtableEntry newElem = new HashtableEntry(key, value); + if (bucket[index] == null) + bucket[index] = newElem; + else + prevElem.nextEntry = newElem; + + if (++hsize > loadFactor * bucket.length) + rehash(); + + return null; + } + + protected void rehash() + { + // Create a new table which is twice the size (plus one) of the old. + // One is added to make the new array length odd so it thus has at least + // a (small) possibility of being a prime number. + HashtableEntry oldBucket[] = bucket; + bucket = new HashtableEntry[bucket.length * 2 + 1]; + + // Copy over each entry into the new table + HashtableEntry elem; + for (int i = 0; i < oldBucket.length; i++) + for (elem = oldBucket[i]; elem != null; elem = elem.nextEntry) + { + // Calling put(elem.key, elem.value); would seem like the easy way + // but it is dangerous since put increases 'hsize' and calls rehash! + // This could become infinite recursion under the right + // circumstances. Instead, we'll add the element directly; this is a + // bit more efficient than put since the data is already verified. + final int index = Math.abs(elem.key.hashCode() % bucket.length); + HashtableEntry newElem = new HashtableEntry(elem.key, elem.value); + if (bucket[index] == null) + bucket[index] = newElem; + else + { + // Since this key can't already be in the table, just add this + // in at the top of the bucket. + newElem.nextEntry = bucket[index]; + bucket[index] = newElem; + } + } + } + + public synchronized Object remove(Object key) + { + // TBD: Hmm, none of the various docs say to throw an exception here. + if (key == null) + return null; + + Object retval; + HashtableEntry prevElem = null; + final int index = Math.abs(key.hashCode() % bucket.length); + + for (HashtableEntry elem = bucket[index]; elem != null; + prevElem = elem, elem = elem.nextEntry) + if (elem.key.equals(key)) + { + retval = elem.value; + if (prevElem == null) + bucket[index] = elem.nextEntry; + else + prevElem.nextEntry = elem.nextEntry; + --hsize; + return retval; + } + + return null; + } + + public int size() + { + return this.hsize; + } + + public synchronized String toString() + { + // Following the Java Lang Spec 21.5.4 (p. 636). + + Enumeration keys = keys(); + Enumeration values = elements(); + + // Prepend first element with open bracket + StringBuffer result = new StringBuffer("{"); + + // add first element if one exists + // TBD: Seems like it is more efficient to catch the exception than + // to call hasMoreElements each time around. + try + { + result.append(keys.nextElement().toString() + "=" + + values.nextElement().toString()); + } + catch (NoSuchElementException ex) + { + } + + // Prepend subsequent elements with ", " + try + { + while (true) + result.append(", " + keys.nextElement().toString() + "=" + + values.nextElement().toString()); + } + catch (NoSuchElementException ex) + { + } + + // Append last element with closing bracket + result.append("}"); + return result.toString(); + } + + // TODO12: + // public Set entrySet() + // { + // } + + // TODO12: + // public Set keySet() + // { + // } + + // Since JDK 1.2: + // This method is identical to contains but is part of the 1.2 Map interface. + // TBD: Should contains return containsValue instead? Depends on which + // will be called more typically. + public synchronized boolean containsValue(Object value) + { + return this.contains(value); + } + + // TODO12: + // public boolean equals(Object o) + // { + // } + + // TODO12: + // public boolean hashCode() + // { + // } + + // TODO12: + // public void putAll(Map t) + // { + // } + + // TODO12: + // public Collection values() + // { + // } +} diff --git a/libjava/java/util/ListResourceBundle.java b/libjava/java/util/ListResourceBundle.java new file mode 100644 index 00000000000..a855c459297 --- /dev/null +++ b/libjava/java/util/ListResourceBundle.java @@ -0,0 +1,52 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Anthony Green + * @date November 26, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3, + * and "The Java Language Specification", ISBN 0-201-63451-1. */ + +public abstract class ListResourceBundle extends ResourceBundle +{ + public final Object handleGetObject(String key) + { + Object a[][] = getContents(); + + for (int i = 0; i < a.length; i++) + { + if (key.compareTo((String) a[i][0]) == 0) + return a[i][1]; + } + throw new MissingResourceException("can't find handle", + getClass().getName(), + key); + } + + public Enumeration getKeys() + { + Object a[][] = getContents(); + + Vector keys = new Vector(a.length); + + for (int i = 0; i < a.length; i++) + keys.addElement(a[i][0]); + + return keys.elements(); + } + + protected abstract Object[][] getContents(); + + public ListResourceBundle() + { + } +} diff --git a/libjava/java/util/Locale.java b/libjava/java/util/Locale.java new file mode 100644 index 00000000000..e47cd1d59d7 --- /dev/null +++ b/libjava/java/util/Locale.java @@ -0,0 +1,125 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Per Bothner + * @date October 24, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3, + * and "The Java Language Specification", ISBN 0-201-63451-1. + * Status: None of the getDisplayXXX or getISO3XXX methods are implemented. + */ +public final class Locale implements java.io.Serializable, Cloneable +{ + // The fields are as specified in Sun's "Serialized Form" + // in the JDK 1.2 beta 4 API specification. + private String country; + private int hashcode; + private String language; + private String variant; + private static Locale defaultLocale; + + // FIXME: many are still missing. + public static final Locale CANADA = new Locale ("en", "CA"); + public static final Locale FRANCE = new Locale ("fr", "FR"); + public static final Locale JAPAN = new Locale ("ja", "JP"); + public static final Locale UK = new Locale ("en", "GB"); + public static final Locale US = new Locale ("en", "US"); + + public Locale (String languageCode, String countryCode) + { + language = languageCode.toLowerCase(); + country = countryCode.toUpperCase(); + hashcode = languageCode.hashCode() ^ countryCode.hashCode(); + } + + public Locale (String languageCode, String countryCode, + String variantCode) + { + this (languageCode, countryCode); + variant = variantCode; + hashcode ^= variantCode.hashCode(); + } + + public Object clone () + { + return (Object) new Locale (language, country, variant); + } + + public boolean equals (Object obj) + { + if (! (obj instanceof Locale)) + return false; + Locale loc = (Locale) obj; + if ((language == null && loc.language != null) + || (country == null && loc.country != null) + || (variant == null && loc.variant != null)) + return false; + return (language.equals(loc.language) + && country.equals(loc.country) + && variant.equals(loc.variant)); + } + + public String getCountry () + { + return country; + } + + public String getLanguage () + { + return language; + } + + public String getVariant () + { + return variant; + } + + public int hashCode () + { + return hashcode; + } + + private static synchronized Locale setDefault() + { + if (defaultLocale != null) + return defaultLocale; + String language = System.getProperty("user.language"); + String country = System.getProperty("user.region"); + defaultLocale = new Locale (language == null ? "en" : language, + country == null ? "" : country); + return defaultLocale; + } + + public static Locale getDefault () + { + return defaultLocale == null ? setDefault() : defaultLocale; + } + + public static void setDefault (Locale newLocale) + { + defaultLocale = newLocale; + } + + public String toString () + { + StringBuffer result = new StringBuffer(20); + result.append(language); + result.append('_'); + result.append(country); + if (variant != null && variant.length() > 0) + { + result.append('_'); + result.append(variant); + } + return result.toString(); + } +} diff --git a/libjava/java/util/MissingResourceException.java b/libjava/java/util/MissingResourceException.java new file mode 100644 index 00000000000..e24cd6aa6dd --- /dev/null +++ b/libjava/java/util/MissingResourceException.java @@ -0,0 +1,43 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date September 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class MissingResourceException extends RuntimeException +{ + private String className; + private String key; + + public MissingResourceException(String msg, String cName, String k) + { + super(msg); + className = cName; + key = k; + } + + public String getClassName() + { + return className; + } + + public String getKey() + { + return key; + } +} + diff --git a/libjava/java/util/NoSuchElementException.java b/libjava/java/util/NoSuchElementException.java new file mode 100644 index 00000000000..2e6d0247c97 --- /dev/null +++ b/libjava/java/util/NoSuchElementException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date September 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class NoSuchElementException extends RuntimeException +{ + public NoSuchElementException() + { + super(); + } + + public NoSuchElementException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/util/Observable.java b/libjava/java/util/Observable.java new file mode 100644 index 00000000000..627892ef061 --- /dev/null +++ b/libjava/java/util/Observable.java @@ -0,0 +1,98 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date September 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class Observable +{ + /* tracks whether this object has changed */ + private boolean changed; + + /* list of the Observers registered as interested in this Observable */ + private Vector observerVec; + + /* TBD: This might be better implemented as an Observer[] + * but that would mean writing more code rather than making use of + * the existing Vector class (this also implies a larger text code + * space in resulting executables). The tradeoff is one of speed + * (manipulating the Observer[] directly) vs. size/reuse. In the future, + * we may decide to make the tradeoff and reimplement with an Observer[]. + */ + + public Observable() + { + changed = false; + observerVec = new Vector(); + } + + public synchronized void addObserver(Observer obs) + { + // JDK 1.2 spec says not to add this if it is already there + if (!observerVec.contains(obs)) + observerVec.addElement(obs); + } + + protected synchronized void clearChanged() + { + changed = false; + } + + public synchronized int countObservers() + { + return observerVec.size(); + } + + public synchronized void deleteObserver(Observer obs) + { + observerVec.removeElement(obs); + } + + public synchronized void deleteObservers() + { + observerVec.removeAllElements(); + } + + public synchronized boolean hasChanged() + { + return changed; + } + + public void notifyObservers() + { + notifyObservers(null); + } + + public void notifyObservers(Object arg) + { + if (changed) + { + /* The JDK 1.2 spec states that though the order of notification + * is unspecified in subclasses, in Observable it is in the order + * of registration. + */ + for (int i = 0, numObs = observerVec.size(); i < numObs; i++) + ((Observer) (observerVec.elementAt(i))).update(this, arg); + changed = false; + } + } + + protected synchronized void setChanged() + { + changed = true; + } +} diff --git a/libjava/java/util/Observer.java b/libjava/java/util/Observer.java new file mode 100644 index 00000000000..c131f3bbc13 --- /dev/null +++ b/libjava/java/util/Observer.java @@ -0,0 +1,24 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date August 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +public interface Observer +{ + public void update(Observable observed, Object arg); +} diff --git a/libjava/java/util/Properties.java b/libjava/java/util/Properties.java new file mode 100644 index 00000000000..aac72147720 --- /dev/null +++ b/libjava/java/util/Properties.java @@ -0,0 +1,376 @@ +// Properties - Property list representation. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.io.PushbackReader; + +/** + * @author Tom Tromey + * @date October 26, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * Status: Complete to JDK 1.1. + */ + +public class Properties extends Hashtable +{ + protected Properties defaults; + + public String getProperty (String propName) + { + return getProperty (propName, null); + } + + public String getProperty (String propName, String defVal) + { + String r = (String) get (propName); + if (r == null) + { + if (defaults != null) + r = defaults.getProperty(propName, defVal); + else + r = defVal; + } + return r; + } + + public void list (PrintStream out) + { + Enumeration e = propertyNames (); + while (e.hasMoreElements()) + { + String key = (String) e.nextElement(); + String value = getProperty(key); + if (value != null) + { + if (value.length() > 40) + { + // JDK compatibility. + value = value.substring(0, 37) + "..."; + } + out.print(key); + out.print("="); + out.println(value); + } + } + } + + public void list (PrintWriter writer) + { + Enumeration e = propertyNames (); + while (e.hasMoreElements()) + { + String key = (String) e.nextElement(); + String value = getProperty(key); + if (value != null) + { + if (value.length() > 40) + { + // JDK compatibility. + value = value.substring(0, 37) + "..."; + } + writer.print(key); + writer.print("="); + writer.println(value); + } + } + } + + private final boolean skip_ws (PushbackReader reader) throws IOException + { + while (true) + { + int c = reader.read(); + if (c == -1) + return false; + // FIXME: we use our own definition of whitespace. + // Character.isWhitespace includes newlines, which we don't + // want. Character.isSpaceChar doesn't include \t. + if (c == ' ' || c == '\t') + { + reader.unread(c); + return true; + } + } + } + + // Note: this method needs to be rewritten for JDK 1.2. + // We rather arbitrarily decide that an EOF in the middle of a line + // means that the whole line should be ignored. The spec doesn't + // specifically address this, but this interpretation seems valid. + public synchronized void load (InputStream in) throws IOException + { + PushbackReader reader = new PushbackReader (new InputStreamReader (in)); + + StringBuffer key = new StringBuffer (); + StringBuffer value = new StringBuffer (); + + nextLine: + while (true) + { + key.setLength(0); + value.setLength(0); + + // Skip leading whitespace. + if (! skip_ws (reader)) + return; + + // Read key until key terminator. + boolean first_char = true; + int c; + while (true) + { + c = reader.read(); + if (c == -1) + return; + if (c == '\\') + { + first_char = false; + c = reader.read(); + if (c == -1) + return; + } + + // If we found a comment, just read to end of line and + // then keep going. + if (first_char == true && (c == '#' || c == '!')) + { + while (c != -1 && c != '\r' && c != '\n') + c = reader.read(); + if (c == -1) + return; + continue nextLine; + } + + if (c == '\r' || c == '\n') + { + if (first_char) + continue nextLine; + reader.unread(c); + break; + } + // FIXME: again, our own definitino of whitespace. + if (c == ' ' || c == '\t' || c == ':' || c == '=') + break; + + first_char = false; + key.append(c); + } + + // Found end of key. Skip whitespace. If the terminator + // was whitespace, also skip a single instance of a "real" + // terminator, and then more whitespace. + if (! skip_ws (reader)) + return; + if (c != ':' && c != '=') + { + c = reader.read(); + if (c == -1) + return; + if (c == ':' || c == '=') + { + // Skip more whitespace. + if (! skip_ws (reader)) + return; + } + else + reader.unread(c); + } + + // Now read the value. + while (true) + { + c = reader.read(); + if (c == -1) + return; + if (c == '\r' || c == '\n') + break; + if (c == '\\') + { + c = reader.read(); + switch (c) + { + case -1: + return; + case 't': + c = '\t'; + break; + case 'r': + c = '\r'; + break; + case 'n': + c = '\n'; + break; + case 'u': + c = 0; + for (int i = 0; i < 4; ++i) + { + int x = reader.read(); + if (x == -1) + return; + int d = Character.digit((char) x, 16); + // FIXME: what to do here? We call it an + // error. + if (d == -1) + throw new IOException (); + c <<= 4; + c |= d; + } + break; + default: + // Nothing. + } + } + else + value.append(c); + } + + put (key.toString(), value.toString()); + } + } + + public Properties () + { + defaults = null; + } + + public Properties (Properties defs) + { + defaults = defs; + } + + private final void addHashEntries (Hashtable base) + { + if (defaults != null) + defaults.addHashEntries(base); + Enumeration keys = keys (); + while (keys.hasMoreElements()) + base.put(keys.nextElement(), base); + } + + public Enumeration propertyNames () + { + // We make a new Hashtable that holds all the keys. Then we + // return an enumeration for this hash. We do this because we + // don't want modifications to be reflected in the enumeration + // (per JCL), and because there doesn't seem to be a + // particularly better way to ensure that duplicates are + // ignored. + Hashtable t = new Hashtable (); + addHashEntries (t); + return t.keys(); + } + + public synchronized void save (OutputStream out, String comment) + { + // Use a buffer because writing a single string through + // OutputStreamWriter is fairly expensive. + BufferedWriter output + = new BufferedWriter (new OutputStreamWriter (out)); + String newline = System.getProperty("line.separator"); + + try + { + if (comment != null) + { + // FIXME: what if COMMENT contains newlines? + output.write("#"); + output.write(comment); + output.write(newline); + } + output.write("# "); + output.write(new Date().toString()); + output.write(newline); + + Enumeration keys = keys (); + while (keys.hasMoreElements()) + { + String key = (String) keys.nextElement(); + String value = (String) get (key); + + // FIXME: JCL says that the key can contain many Unicode + // characters. But it also doesn't say we should encode + // it in any way. + // FIXME: if key contains ':', '=', or whitespace, must + // quote it here. + output.write(key); + output.write("="); + + boolean leading = true; + for (int i = 0; i < value.length(); ++i) + { + boolean new_lead = false; + char c = value.charAt(i); + switch (c) + { + case '\n': + output.write("\\n"); + break; + case '\r': + output.write("\\r"); + break; + case '\t': + output.write("\\t"); + break; + case '\\': + output.write("\\\\"); + break; + + case '#': + case '!': + case '=': + case ':': + output.write("\\"); + output.write(c); + break; + + case ' ': + new_lead = leading; + if (leading) + output.write("\\"); + output.write(c); + break; + + default: + if (c < '\u0020' || c > '\u007e') + { + output.write("\\u"); + output.write(Character.forDigit(c >>> 12, 16)); + output.write(Character.forDigit((c >>> 8) & 0xff, + 16)); + output.write(Character.forDigit((c >>> 4) & 0xff, + 16)); + output.write(Character.forDigit(c & 0xff, 16)); + } + else + output.write(c); + } + leading = new_lead; + } + output.write(newline); + } + + output.flush(); + } + catch (IOException ignore) + { + } + } +} diff --git a/libjava/java/util/Random.java b/libjava/java/util/Random.java new file mode 100644 index 00000000000..26010ce96f9 --- /dev/null +++ b/libjava/java/util/Random.java @@ -0,0 +1,148 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +import java.io.Serializable; + +/** + * @author Warren Levy + * @date August 25, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +/* This class is completely specified by the spec to ensure absolute + * portability between all implementations of Java + */ +public class Random implements Serializable +{ + /* Used by next() to hold the state of the pseudorandom number generator */ + protected long seed; + + /* Used by nextGaussian() to hold a precomputed value */ + /* to be delivered by that method the next time it is called */ + protected double nextNextGaussian; + + /* Used by nextGaussian() to keep track of whether it is has precomputed */ + /* and stashed away the next value to be delivered by that method */ + protected boolean haveNextNextGaussian = false; + + public Random() + { + this(System.currentTimeMillis()); + } + + public Random(long seed) + { + setSeed(seed); + } + + protected synchronized int next(int bits) + { + seed = (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1); + return (int)(seed >>> (48 - bits)); + } + + // JDK1.2 + public boolean nextBoolean() + { + return next(1) != 0; + } + + /* The method nextBytes() is not fully specified in the published specs. + * At first I implemented it simply via: + * for (int i = 0; i < buf.length; i++) + * buf[i] = (byte)next(8); + * but a simple test did not yield the same results as the std implementation. + * There seemed to be a relationship where each i byte above was at pos 4*i+3 + * in the std. For efficiency, by reducing calls to the expensive math + * routines, the std probably was calling next(32) once rather than next(8) + * 4 times. Changing the algorithm to the one below based on that assumption + * then yielded identical results to the std. + */ + public void nextBytes(byte[] buf) + { + int randInt = 0; + + for (int i = 0; i < buf.length; i++) + { + int shift = (i % 4) * 8; + if (shift == 0) + randInt = next(32); + buf[i] = (byte) (randInt >> shift); + } + } + + public double nextDouble() + { + return (((long)next(26) << 27) + next(27)) / (double)(1L << 53); + } + + public float nextFloat() + { + return next(24) / ((float)(1 << 24)); + } + + public synchronized double nextGaussian() + { + if (haveNextNextGaussian) + { + haveNextNextGaussian = false; + return nextNextGaussian; + } + else + { + double v1, v2, s; + do + { + v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0 + v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0 + s = v1 * v1 + v2 * v2; + } while (s >= 1); + double norm = Math.sqrt(-2 * Math.log(s)/s); + nextNextGaussian = v2 * norm; + haveNextNextGaussian = true; + return v1 * norm; + } + } + + public int nextInt() + { + return next(32); + } + + // JDK1.2 + public int nextInt(int n) + { + if (n <= 0) + throw new IllegalArgumentException("n must be positive"); + + int bits, val; + do + { + bits = next(31); + val = bits % n; + } while (bits - val + (n-1) < 0); + return val; + } + + public long nextLong() + { + return ((long)next(32) << 32) + next(32); + } + + public synchronized void setSeed(long seed) + { + this.seed = (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1); + haveNextNextGaussian = false; + } +} diff --git a/libjava/java/util/ResourceBundle.java b/libjava/java/util/ResourceBundle.java new file mode 100644 index 00000000000..ba1d3f9fdcb --- /dev/null +++ b/libjava/java/util/ResourceBundle.java @@ -0,0 +1,188 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Anthony Green + * @date November 26, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3, + * and "The Java Language Specification", ISBN 0-201-63451-1. */ + +public abstract class ResourceBundle +{ + protected ResourceBundle parent; + + public ResourceBundle () + { + } + + public final String getString (String key) throws MissingResourceException + { + return (String) getObject(key); + } + + public final String[] getStringArray (String key) + throws MissingResourceException + { + return (String[]) getObject(key); + } + + public final Object getObject(String key) throws MissingResourceException + { + Object result; + + try + { + return handleGetObject (key); + } + catch (MissingResourceException ex) + { + if (parent != null) + return parent.getObject(key); + else + throw ex; + } + } + + public static final ResourceBundle getBundle(String baseName) + throws MissingResourceException + { + return getBundle(baseName, Locale.getDefault()); + } + + // Start searching with the name bundleName. Continue searching by + // stripping off the '_' delimited tails until the search name is + // the same as stopHere. + private static final ResourceBundle trySomeGetBundle (String bundleName, + String stopHere) + { + Class rbc; + + while (true) + { + try + { + rbc = Class.forName(bundleName); + try + { + return (ResourceBundle) rbc.newInstance(); + } + catch (IllegalAccessException ex) + { + // Fall through + } + catch (InstantiationException ex) + { + // Fall through + } + return null; + } + catch (ClassNotFoundException ex) + { + if (bundleName.compareTo(stopHere) == 0) + return null; + else + { + int last = bundleName.lastIndexOf('_'); + + // No more underscores? + if (last == -1) + return null; + + // Loop around, testing this new shorter name. + bundleName = bundleName.substring(0, last); + } + } + } + } + + // Search for bundles, but stop at baseName_language. + private static final ResourceBundle partialGetBundle (String baseName, + Locale locale) + { + ResourceBundle rb; + + String bundleName = (baseName + + "_" + + locale.getLanguage() + "_" + + locale.getCountry() + "_" + + locale.getVariant()); + + String stopHere = (baseName + + "_" + + locale.getLanguage()); + + + rb = trySomeGetBundle(bundleName, stopHere); + + return rb; + } + + public static final ResourceBundle getBundle (String baseName, + Locale locale) + throws MissingResourceException + { + ResourceBundle rb; + Class rbc; + + // FIXME: We can't currently rely on NullPointerException being + // thrown when we invoke a method on a null object. + if (locale == null) + throw new NullPointerException (); + + rb = partialGetBundle(baseName, locale); + if (rb != null) + return rb; + + if (! locale.equals(Locale.getDefault())) + { + rb = partialGetBundle(baseName, Locale.getDefault()); + if (rb != null) + return rb; + } + + // Try just the baseName. + try + { + rbc = Class.forName (baseName); + try + { + return (ResourceBundle) rbc.newInstance(); + } + catch (IllegalAccessException ex) + { + // Fall through. + } + catch (InstantiationException ex) + { + // Fall through. + } + } + catch (ClassNotFoundException ex) + { + // Fall through. + } + + throw new MissingResourceException("can't load bundle", + baseName, + "bundle"); + } + + protected void setParent(ResourceBundle parent) + { + this.parent = parent; + } + + protected abstract Object handleGetObject(String key) + throws MissingResourceException; + + public abstract Enumeration getKeys(); +} diff --git a/libjava/java/util/SimpleTimeZone.java b/libjava/java/util/SimpleTimeZone.java new file mode 100644 index 00000000000..6082b1816e5 --- /dev/null +++ b/libjava/java/util/SimpleTimeZone.java @@ -0,0 +1,182 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Per Bothner + * @date October 24, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3. + * Status: Does not know how to figure out if daylight savings time + * is in effect; hence only correct for zones without DST. + * No known spec for hashCode. + */ + +public class SimpleTimeZone extends TimeZone +{ + // The fields are as specified in Sun's "Serialized Form" + // in the JDK 1.2 beta 4 API specification. + + int dstSavings = 60 * 60 * 1000; + + int rawOffset; + + // int serialVersionOnStream; + + int startDay; + int startDayOfWeek; + int startMode; /// Seems to be JDK 1.2 only. + + int startMonth; + + int startTime; + + int startYear; + + int endDay; + + int endDayOfWeek; + + int endMode; // Seems to be JDK 1.2 only. + + int endMonth; + + int endTime; + + // byte[] monthLength; + + boolean useDaylight; + + public SimpleTimeZone (int rawOffset, String ID) + { + setID(ID); + this.rawOffset = rawOffset; + } + + public SimpleTimeZone (int rawOffset, String ID, + int startMonth, int startDay, + int startDayOfWeek, int startTime, + int endMonth, int endDay, + int endDayOfWeek, int endTime) + { + this(rawOffset, ID); + setStartRule (startMonth, startDay, startDayOfWeek, startTime); + setEndRule (endMonth, endDay, endDayOfWeek, endTime); + } + + public int getRawOffset() { return rawOffset; } + public void setRawOffset (int offsetMillis) { rawOffset = offsetMillis; } + + public int getOffset (int era, int year, int month, int day, + int dayOfWeek, int millis) + { + int offset = getRawOffset(); + if (useDaylight) + { + if (startYear != 0 + && (year < startYear || era == GregorianCalendar.BC)) + return offset; + boolean midYearSummer = startMonth < endMonth; + if (midYearSummer ? (month < startMonth || month > endMonth) + : (month < startMonth && month > endMonth)) + return offset; // Definitely not DST. + if (midYearSummer ? (month > startMonth && month < endMonth) + : (month > startMonth || month < endMonth)) + return offset + dstSavings; // Definitely DST. + // Now it gets more complicated. Bail for now. + throw new Error("not implemented - SimpleTimeZone.getOffset"); + } + return offset; + } + + public boolean useDaylightTime() { return useDaylight; } + + public boolean inDaylightTime(Date date) + { + if (! useDaylight) + return false; + throw new Error("not implemented - SimpleTimeZone.inDaylightTime"); + } + + public int getDSTSavings () { return dstSavings; } + + public void setDSTSavings (int millisSavedDuringDST) + { dstSavings = millisSavedDuringDST; } + + public void setStartRule (int month, int dayOfWeekInMonth, + int dayOfWeek, int time) + { + this.startMonth = month; + this.startDay = dayOfWeekInMonth; + this.startDayOfWeek = dayOfWeek; + this.startTime = time; + this.useDaylight = true; + } + + public void setEndRule (int month, int dayOfWeekInMonth, + int dayOfWeek, int time) + { + this.endMonth = month; + this.endDay = dayOfWeekInMonth; + this.endDayOfWeek = dayOfWeek; + this.endTime = time; + this.useDaylight = true; + } + + public void setStartYear (int year) + { + this.startYear = startYear; + } + + public boolean hasSameRules (TimeZone other) + { + if (this == other) + return true; + if (! (other instanceof SimpleTimeZone)) + return false; + SimpleTimeZone o = (SimpleTimeZone) other; + if (rawOffset != o.rawOffset) + return false; + if (useDaylight != o.useDaylight) + return false; + if (! useDaylight) + return true; + return startDay == o.startDay + && startDayOfWeek == o.startDayOfWeek + && startMonth == o.startMonth + && startTime == o.startTime + && endDay == o.endDay + && endDayOfWeek == o.endDayOfWeek + && endMonth == o.endMonth + && endTime == o.endTime + && startYear == o.startYear + && startMode == o.startMode + && endMode == o.endMode; + } + + public boolean equals (Object obj) + { + if (! (obj instanceof SimpleTimeZone)) + return false; + SimpleTimeZone other = (SimpleTimeZone) obj; + return getID() == other.getID() && hasSameRules(other); + } + + public int hashCode () + { + // FIXME - this does not folow any spec (since none is public)! + int hash = rawOffset; + if (useDaylight) + hash += dstSavings + startYear + startMode + endMode + + startDay + startDayOfWeek + startMonth + startTime + + endDay + endDayOfWeek + endMonth + endTime; + return hash; + } +} diff --git a/libjava/java/util/Stack.java b/libjava/java/util/Stack.java new file mode 100644 index 00000000000..bc4588898cb --- /dev/null +++ b/libjava/java/util/Stack.java @@ -0,0 +1,74 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date August 20, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +public class Stack extends Vector +{ + // Could use Vector methods internally for the following methods + // but have used Vector fields directly for efficiency (i.e. this + // often reduces out duplicate bounds checking). + + public boolean empty() + { + return elementCount == 0; + } + + public synchronized Object peek() + { + if (elementCount == 0) + throw new EmptyStackException(); + + return elementData[elementCount - 1]; + } + + public synchronized Object pop() + { + if (elementCount == 0) + throw new EmptyStackException(); + + Object obj = elementData[--elementCount]; + + // Set topmost element to null to assist the gc in cleanup + elementData[elementCount] = null; + return obj; + } + + public Object push(Object obj) + { + // When growing the Stack, use the Vector routines in case more + // memory is needed. + // Note: spec indicates that this method *always* returns obj passed in! + + addElement(obj); + return obj; + } + + public synchronized int search(Object obj) + { + // Return the position of obj on the stack as measured from the top; + // i.e. the top element is 1, the next element down is 2, etc. + // If obj is not on the stack, return -1 + + for (int i = elementCount-1; i >=0; --i) + if (elementData[i].equals(obj)) + return elementCount - i; + + return -1; + } +} diff --git a/libjava/java/util/StringTokenizer.java b/libjava/java/util/StringTokenizer.java new file mode 100644 index 00000000000..4516057f2d9 --- /dev/null +++ b/libjava/java/util/StringTokenizer.java @@ -0,0 +1,185 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date August 24, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +public class StringTokenizer implements Enumeration +{ + /* String to be parsed */ + private String inputString; + + /* String to be parsed put into a char array for efficient access */ + private char[] chArray; + + /* Set of delimiter characters for separating tokens */ + private String delimiters; + + /* Whether delimiters in this instance are treated as tokens themselves */ + private boolean returnDelimiters; + + /* Index into the input string to start parsing for the next token */ + private int inputStringIndex; + + public StringTokenizer(String str) + { + this(str, " \t\n\r", false); + } + + public StringTokenizer(String str, String delims) + { + this(str, delims, false); + } + + public StringTokenizer(String str, String delims, boolean retDelim) + { + inputString = str; + delimiters = delims; + returnDelimiters = retDelim; + inputStringIndex = 0; + + // Work on a copy of the remaining string in a char array + // to gain efficiency of using primitives + chArray = new char[inputString.length()]; + inputString.getChars(0, inputString.length(), chArray, 0); + } + + public int countTokens() + { + int count = 0; + int delimiterCount = 0; + boolean tokenFound = false; // Set when a non-delimiter is found + int offset = inputStringIndex; + + // Note for efficiency, we count up the delimiters rather than check + // returnDelimiters every time we encounter one. That way, we can + // just do the conditional once at the end of the method + while (offset < chArray.length) + { + if (isDelimiter(chArray[offset++])) + { + if (tokenFound) + { + // Got to the end of a token + count++; + tokenFound = false; + } + + delimiterCount++; // Increment for this delimiter + } + else + { + tokenFound = true; + + // Get to the end of the token + while (offset < chArray.length && !isDelimiter(chArray[offset])) + offset++; + } + } + + // Make sure to count the last token + if (tokenFound) + count++; + + // if counting delmiters add them into the token count + return returnDelimiters ? count + delimiterCount : count; + } + + public boolean hasMoreElements() + { + return hasMoreTokens(); + } + + public boolean hasMoreTokens() + { + int offset = inputStringIndex; + + while (offset < chArray.length) + if (!isDelimiter(chArray[offset++]) || returnDelimiters) + { + // update the current position with the start of the next token + inputStringIndex = --offset; + + return true; + } + + return false; + } + + public Object nextElement() + { + return nextToken(); + } + + public String nextToken() + { + int offset = inputStringIndex; + int startSubstr = -1; + + // Make sure we have more chars left to parse + // and then find the start of the next token + while (offset < chArray.length && startSubstr < 0) + { + // Find the start of the token; skipping initial delimiters + if (!isDelimiter(chArray[offset++])) + startSubstr = offset - 1; + else if (returnDelimiters) + { + // The single char delimiter is treated as a token + inputStringIndex = offset; // update the current position + + return inputString.substring(offset - 1, inputStringIndex); + } + } + + // Now look for the end of the token + while (offset < chArray.length) + { + if (isDelimiter(chArray[offset++])) + { + // Found the end of token + inputStringIndex = offset - 1; // update the current position + + return inputString.substring(startSubstr, inputStringIndex); + } + } + + // Got to the end of the string without finding the start of a token + if (startSubstr < 0) + throw new NoSuchElementException(); + + // Got to the end of the string before a delimiter + inputStringIndex = offset; // update the current position + + return inputString.substring(startSubstr, inputStringIndex); + } + + public String nextToken(String delims) + { + // First replace with new set of delimiters + delimiters = delims; + + return nextToken(); + } + + // This private method could be inlined but the other methods are + // more readable this way, so we'll take the hit on efficiency. + private boolean isDelimiter(char ch) + { + return delimiters.indexOf(ch) >= 0; + } +} diff --git a/libjava/java/util/TimeZone.java b/libjava/java/util/TimeZone.java new file mode 100644 index 00000000000..ad2dd628b1f --- /dev/null +++ b/libjava/java/util/TimeZone.java @@ -0,0 +1,120 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Per Bothner + * @date October 24, 1998. + */ + +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3. + * Status: getAvailableIDs, getDefault, getTimeZone only know about GMT. + */ + +public abstract class TimeZone implements java.io.Serializable, Cloneable +{ + public static final int SHORT = 0; + public static final int LONG = 1; + + // The fields are as specified in Sun's "Serialized Form" + // in the JDK 1.2 beta 4 API specification. + String ID; + + static final TimeZone zoneGMT = new SimpleTimeZone(0, "GMT"); + + private static TimeZone zoneDefault; + + public TimeZone () + { + } + + public abstract int getOffset (int era, int year, int month, + int day, int dayOfWeek, int milliseconds); + + public abstract void setRawOffset (int offsetMillis); + + public abstract int getRawOffset (); + + public String getID () { return ID; } + + public void setID (String ID) { this.ID = ID; } + + public final String getDisplayName() + { + return ID; // FIXME + } + + // public final String getDisplayName (Local locale) { ... } FIXME + + public final String getDisplayName (boolean daylight, int style) + { + return ID; // FIXME + } + + /* + public final String getDisplayName (boolean daylight, int style, Locale locale) + { + return ID; // FIXME + } + */ + + public abstract boolean useDaylightTime(); + + public abstract boolean inDaylightTime (Date date); + + public static TimeZone getTimeZone (String ID) + { + return zoneGMT; // FIXME + } + + public static String[] getAvailableIDs() + { // FIXME - only knows about GMT + String[] zones = new String[1]; + zones[0] = "GMT"; + return zones; + } + + public static String[] getAvailableIDs(int rawOffset) + { + return rawOffset == 0 ? getAvailableIDs() : new String[0]; // FIXME + } + + private static synchronized TimeZone setDefault() + { + if (zoneDefault == null) + { + try + { + String id = System.getProperty("user.timezone"); + if (id != null && ! id.equals("GMT")) + zoneDefault = getTimeZone(id); + } + catch (Exception ex) + { + } + if (zoneDefault == null) + zoneDefault = zoneGMT; + } + return zoneDefault; + } + + public static TimeZone getDefault() + { + return zoneDefault == null ? setDefault() : zoneDefault; + } + + public static void setDefault (TimeZone zone) { zoneDefault = zone; } + + public boolean hasSameRules (TimeZone other) + { + return this == other; + } + + // public Object clone (); +} diff --git a/libjava/java/util/TooManyListenersException.java b/libjava/java/util/TooManyListenersException.java new file mode 100644 index 00000000000..13bbc4ecae3 --- /dev/null +++ b/libjava/java/util/TooManyListenersException.java @@ -0,0 +1,32 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +/** + * @author Warren Levy + * @date September 2, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct. + */ + +public class TooManyListenersException extends Exception +{ + public TooManyListenersException() + { + super(); + } + + public TooManyListenersException(String msg) + { + super(msg); + } +} diff --git a/libjava/java/util/Vector.java b/libjava/java/util/Vector.java new file mode 100644 index 00000000000..aaa9ea27632 --- /dev/null +++ b/libjava/java/util/Vector.java @@ -0,0 +1,450 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util; + +import java.io.Serializable; + +/** + * @author Warren Levy + * @date August 17, 1998. + */ +/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 + * "The Java Language Specification", ISBN 0-201-63451-1 + * plus online API docs for JDK 1.2 beta from http://www.javasoft.com. + * Status: Believed complete and correct + */ + +class VectorEnumeration implements Enumeration +{ + private int enumIndex; + private Vector enumVec; + + public VectorEnumeration(Vector vec) + { + enumVec = vec; + enumIndex = 0; + } + + public boolean hasMoreElements() + { + return enumIndex < enumVec.size(); + } + + public Object nextElement() + { + if (!hasMoreElements()) + throw new NoSuchElementException(); + + return enumVec.elementData[enumIndex++]; + } +} + +// TODO12: +// public class Vector extends AbstractList +// implements List, Cloneable, Serializable + +public class Vector implements Cloneable, Serializable +{ + /* The size of the increment to use when growing this vector. + The default of 0 means to double the capacity when growing. */ + protected int capacityIncrement; + + /* The number of elements currently in elementData */ + protected int elementCount; + + /* The buffer in which elements of this vector are stored */ + protected Object[] elementData; + + public Vector() + { + this(10, 0); + } + + public Vector(int initCap) + { + this(initCap, 0); + } + + public Vector(int initCap, int capIncrement) + { + if (initCap < 0) + throw new IllegalArgumentException (); + elementData = new Object[initCap]; + capacityIncrement = capIncrement; + elementCount = 0; + } + + public final synchronized void addElement(Object obj) + { + // Make sure there's room for a new element + if (elementCount == elementData.length) + ensureCapacity(elementCount+1); + + elementData[elementCount++] = obj; + } + + public final int capacity() + { + return elementData.length; + } + + public synchronized Object clone() + { + // New vector needs to have same size, capacity and capacityIncrement + Vector newVec = new Vector(elementData.length, capacityIncrement); + + System.arraycopy(elementData, 0, newVec.elementData, 0, elementCount); + newVec.elementCount = elementCount; + return newVec; + } + + public final boolean contains(Object obj) + { + for (int i = 0; i < elementCount; i++) + { + if (obj == null + ? elementData[i] == null + : obj.equals(elementData[i])) + return true; + } + + return false; + } + + public final synchronized void copyInto(Object[] objArray) + { + System.arraycopy(elementData, 0, objArray, 0, elementCount); + } + + public final synchronized Object elementAt(int idx) + { + if (idx < 0 || idx >= size()) + throw new ArrayIndexOutOfBoundsException(); + + return elementData[idx]; + } + + public final synchronized Enumeration elements() + { + return new VectorEnumeration(this); + } + + public final synchronized void ensureCapacity(int minCap) + { + // Increasing the vector could make it much larger than minCap; + // e.g. if minCap is just larger than the vector, size may double. + // If someone cares about this possibility they should set capacityIncrement + if (minCap > elementData.length) + { + // Increase the vector; double it if capacityIncrement is zero + int newSize = elementData.length; + newSize += + (capacityIncrement > 0) ? capacityIncrement : elementData.length; + + // Make sure newSize is at least minCap + if (newSize < minCap) + newSize = minCap; + + Object[] newArray = new Object[newSize]; + System.arraycopy(elementData, 0, newArray, 0, elementCount); + elementData = newArray; + } + } + + public final synchronized Object firstElement() + { + if (elementCount == 0) + throw new NoSuchElementException(); + + return elementData[0]; + } + + public final int indexOf(Object obj) + { + return indexOf(obj, 0); + } + + public final synchronized int indexOf(Object obj, int idx) + { + if (idx < 0) + throw new IllegalArgumentException (); + for (int i = idx; i < elementCount; i++) + { + if (obj == null + ? elementData[i] == null + : obj.equals(elementData[i])) + return i; + } + + return -1; + } + + public final synchronized void insertElementAt(Object obj, int idx) + { + if (idx < 0 || idx > size()) + throw new ArrayIndexOutOfBoundsException(); + else if (idx == size()) // Spec says just use addElement() + addElement(obj); + else + { + // Make sure there's room for a new element + if (elementCount == elementData.length) + ensureCapacity(elementCount+1); + + // Shift the existing elements up and increment elementCount + for (int i = elementCount++; i > idx; --i) + elementData[i] = elementData[i-1]; + + elementData[idx] = obj; + } + } + + public final boolean isEmpty() + { + return elementCount == 0; + } + + public final synchronized Object lastElement() + { + if (elementCount == 0) + throw new NoSuchElementException(); + + return elementData[elementCount - 1]; + } + + public final int lastIndexOf(Object obj) + { + return lastIndexOf(obj, size()-1); + } + + public final synchronized int lastIndexOf(Object obj, int idx) + { + if (idx < 0) + throw new IllegalArgumentException (); + for (int i = idx; i >= 0; --i) + { + if (obj == null + ? elementData[i] == null + : obj.equals(elementData[i])) + return i; + } + + return -1; + } + + public final synchronized void removeAllElements() + { + // Remove elements now to assist the gc in early cleanup + for (int i = elementCount-1; i >= 0; --i) + elementData[i] = null; + elementCount = 0; + } + + public final synchronized boolean removeElement(Object obj) + { + for (int i = 0; i < elementCount; i++) + { + if (obj == null + ? elementData[i] == null + : obj.equals(elementData[i])) + { + int j; + + // Decrement count first to ensure we don't walk off end of array + --elementCount; + + for (j = i; j < elementCount; j++) + elementData[j] = elementData[j+1]; + + // At this point, j was incrememented and points to old last element + // Remove element now to assist the gc in early cleanup + elementData[j] = null; + return true; + } + } + + return false; + } + + public final synchronized void removeElementAt(int idx) + { + int i; + + if (idx < 0 || idx >= size()) + throw new ArrayIndexOutOfBoundsException(); + + // Decrement count first to ensure we don't walk off the end of the array + --elementCount; + + for (i = idx; i < elementCount; i++) + elementData[i] = elementData[i+1]; + + // At this point, i was incrememented and now points to the old last element + // Remove element now to assist the gc in early cleanup + elementData[i] = null; + } + + public final synchronized void setElementAt(Object obj, int idx) + { + if (idx < 0 || idx >= size()) + throw new ArrayIndexOutOfBoundsException(); + + elementData[idx] = obj; + } + + public final synchronized void setSize(int newSize) + { + if (newSize < 0) + throw new ArrayIndexOutOfBoundsException(); + + // Java Lang Spec p. 658 says to remove the excess elements and discard + // when new size is smaller than old size. + // When truncating, we could alternatively just reset elementCount instead + // of freeing up the memory if the spec hadn't specified. The spec makes + // sense though; if someone cares enough to call a setSize() function + // they probably are doing so to free memory. + if (newSize < elementCount) + { + elementCount = newSize; + trimToSize(); + } + else if (newSize > elementCount) // Skip == case + { + // TBD: ensureCapacity() may create a vector much larger than newSize; + // do we want to make the vector exactly newSize? Spec is unclear. + ensureCapacity(newSize); + + // Make sure to null out new elements of grown vector + for (int i = elementCount; i < newSize; i++) + elementData[i] = null; + elementCount = newSize; + } + } + + public final int size() + { + return elementCount; + } + + public final synchronized String toString() + { + // Following the Java Lang Spec p. 656 + + // Prepend first element with open bracket + StringBuffer result = new StringBuffer("["); + + if (elementCount > 0) // add first element if one exists + result.append(elementData[0].toString()); + + // Prepend subsequent elements with ", " + for (int i = 1; i < elementCount; i++) + result.append(", ").append(elementData[i].toString()); + + // Append last element with closing bracket + result.append("]"); + return result.toString(); + } + + public final synchronized void trimToSize() + { + // Give up excess storage capacity to save memory + // + // Don't bother checking for the case where size() == the capacity of the + // vector since that is a much less likely case; it's more efficient to + // not do the check and lose a bit of performance in that infrequent case + Object[] newArray = new Object[elementCount]; + System.arraycopy(elementData, 0, newArray, 0, elementCount); + elementData = newArray; + } + + // TODO12: + // public Vector(Collection c) + // { + // } + + // TODO12: + // public public boolean add(Object o) + // { + // } + + // TODO12: + // public void add(int index, Object element) + // { + // } + + // TODO12: + // public boolean addAll(Collection c) + // { + // } + + // TODO12: + // public boolean addAll(int index, Collection c) + // { + // } + + // TODO12: + // public void clear() + // { + // } + + // TODO12: + // public boolean containsAll(Collection c) + // { + // } + + // TODO12: + // public boolean equals(Object o) + // { + // } + + // TODO12: + // public int hashCode() + // { + // } + + // TODO12: + // public Object get(int index) + // { + // } + + // TODO12: + // public boolean remove(Object o) + // { + // } + + // TODO12: + // public Object remove(int index) + // { + // } + + // TODO12: + // public boolean removeAll(Collection c) + // { + // } + + // TODO12: + // public boolean retainAll(Collection c) + // { + // } + + // TODO12: + // public Object set(int index, Object element) + // { + // } + + // TODO12: + // public Object[] toArray() + // { + // } + + // TODO12: + // public Object[] toArray(Object[] a) + // { + // } +} diff --git a/libjava/java/util/natDate.cc b/libjava/java/util/natDate.cc new file mode 100644 index 00000000000..27f91f6fa19 --- /dev/null +++ b/libjava/java/util/natDate.cc @@ -0,0 +1,45 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +// We want to make sure to pick up the POSIX ctime_r. Some systems, +// such as Solaris 2.6, have their own version as well. +#ifdef HAVE_CTIME_R +#define _POSIX_PTHREAD_SEMANTICS +#endif + +#include +#include +#include + +#include + +#ifdef HAVE_SYS_TYPES_H +#include +#endif + +#ifdef HAVE_SYS_TIME_H +#include +#endif + +jstring +java::util::Date::toString() +{ +#ifdef HAVE_CTIME_R + time_t t = millis / 1000; + char buf[30]; + return JvNewStringLatin1 (ctime_r (&t, buf)); +#elif defined (HAVE_CTIME) + // FIXME: this isn't thread-safe. + time_t t = millis / 1000; + return JvNewStringLatin1 (ctime (&t)); +#else + return NULL; +#endif +} diff --git a/libjava/java/util/natGregorianCalendar.cc b/libjava/java/util/natGregorianCalendar.cc new file mode 100644 index 00000000000..cfa98bdc58d --- /dev/null +++ b/libjava/java/util/natGregorianCalendar.cc @@ -0,0 +1,124 @@ +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +// We want to make sure to pick up the POSIX `_r' functions. Some +// systems, such as Solaris 2.6, require this define in order to +// declare the functions in the appropriate header. +#if defined (HAVE_GMTIME_R) || defined (HAVE_LOCALTIME_R) +# define _POSIX_PTHREAD_SEMANTICS +# ifndef _REENTRANT +# define _REENTRANT +# endif /* _REENTRANT */ +#endif + +#ifdef ECOS +#include +#endif + +#include +#include +#include +#include + +void +java::util::GregorianCalendar::computeTime () +{ + struct tm tim; + tim.tm_sec = elements(fields)[SECOND]; + tim.tm_min = elements(fields)[MINUTE]; + tim.tm_hour = elements(fields)[HOUR_OF_DAY]; + tim.tm_mday = elements(fields)[DATE]; + tim.tm_mon = elements(fields)[MONTH]; + tim.tm_year = elements(fields)[YEAR] - 1900; + tim.tm_isdst = 0; // FIXME +#ifndef ECOS + // FIXME: None of the standard C library access to the ECOS calendar + // is yet available. + time_t t = mktime (&tim); +#else + time_t t = 0; +#endif + + // Adjust for local timezone (introduced by mktime) and our + // timezone. +#if defined (STRUCT_TM_HAS_GMTOFF) + t += tim.tm_gmtoff; +#elif defined (HAVE_TIMEZONE) + t -= timezone; +#endif + java::util::TimeZone *zone = getTimeZone (); + t += zone->getRawOffset(); + + // Adjust for milliseconds. + time = t * 1000 + elements(fields)[MILLISECOND]; + + isTimeSet = true; +} + +void +java::util::GregorianCalendar::computeFields () +{ + time_t t = time / 1000; + int millis = time % 1000; + if (t < 0 && millis != 0) + { + t--; + millis = t - 1000 * t; + } + elements(fields)[MILLISECOND] = millis; + struct tm tim; + java::util::TimeZone *zone = getTimeZone (); + + // FIXME: None of the standard C library access to the ECOS calendar + // is yet available. +#ifdef ECOS + memset (&tim, 0, sizeof tim); +#else + if (zone->getRawOffset() == 0 || ! zone->useDaylightTime()) + { +#if defined(__JV_POSIX_THREADS__) && defined(HAVE_GMTIME_R) + gmtime_r (&t, &tim); +#else + // Get global lock (because gmtime uses a global buffer). FIXME + tim = *(struct tm*) gmtime (&t); + // Release global lock. FIXME +#endif + } + else + { +#if defined(__JV_POSIX_THREADS__) && defined(HAVE_LOCALTIME_R) + localtime_r (&t, &tim); +#else + // Get global lock (because localtime uses a global buffer). FIXME + tim = *(struct tm*) localtime (&t); + // Release global lock. FIXME +#endif + } +#endif /* ECOS */ + elements(fields)[SECOND] = tim.tm_sec; + elements(fields)[MINUTE] = tim.tm_min; + elements(fields)[HOUR_OF_DAY] = tim.tm_hour; + elements(fields)[AM_PM] = tim.tm_hour < 12 ? AM : PM; + elements(fields)[HOUR] = tim.tm_hour % 12; + elements(fields)[DATE] = tim.tm_mday; + elements(fields)[MONTH] = tim.tm_mon; + elements(fields)[YEAR] = 1900 + tim.tm_year; + elements(fields)[DAY_OF_WEEK] = tim.tm_wday + 1; + elements(fields)[DAY_OF_WEEK_IN_MONTH] = ((tim.tm_mday - 1) / 7) + 1; + elements(fields)[DAY_OF_YEAR] = tim.tm_yday + 1; + elements(fields)[WEEK_OF_MONTH] + = (tim.tm_mday + 6 + (5 - tim.tm_wday + getFirstDayOfWeek()) % 7) / 7; + elements(fields)[WEEK_OF_YEAR] + = (tim.tm_yday + 7 + (5 - tim.tm_wday + getFirstDayOfWeek()) % 7) / 7; + elements(fields)[ERA] = AD; + elements(fields)[DST_OFFSET] = tim.tm_isdst <= 0 ? 0 : 60*60*1000; + elements(fields)[ZONE_OFFSET] = getTimeZone()->getRawOffset(); + areFieldsSet = true; +} diff --git a/libjava/java/util/zip/Adler32.java b/libjava/java/util/zip/Adler32.java new file mode 100644 index 00000000000..8e4ab9ae193 --- /dev/null +++ b/libjava/java/util/zip/Adler32.java @@ -0,0 +1,101 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; + +/** + * @author Per Bothner + * @date April 6, 1999. + */ + +/* + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * The actual Adler32 algorithm is taken from RFC 1950. + * Status: Believed complete and correct. + */ + +public class Adler32 implements Checksum +{ + private static int BASE = 65521; /* largest prime smaller than 65536 */ + + int s1; + int s2; + + public Adler32 () + { + reset(); + } + + public void reset () { s1 = 1; s2 = 0; } + + public void update (int bval) + { + s1 = (s1 + (bval & 0xFF)) % BASE; + s2 = (s1 + s2) % BASE; + } + + public void update (byte[] buffer) + { + update(buffer, 0, buffer.length); + } + + public void update (byte[] buf, int off, int len) + { + int s1 = this.s1; + int s2 = this.s2; + while (len > 0) + { + // We can defer the modulo operation. + int n = 4000; + if (n > len) + n = len; + len -= n; + while (--n >= 0) + { + s1 = s1 + (buf[off++] & 0xFF); + s2 = s2 + s1; + } + s1 %= BASE; + s2 %= BASE; + } + this.s1 = s1; + this.s2 = s2; + } + + public long getValue() + { + return ((long) s2 << 16) + s1; + } +} + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libjava/java/util/zip/CRC32.java b/libjava/java/util/zip/CRC32.java new file mode 100644 index 00000000000..ab19b58b1e9 --- /dev/null +++ b/libjava/java/util/zip/CRC32.java @@ -0,0 +1,70 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; + +/** + * @author Per Bothner + * @date April 1, 1999. + */ + +/* + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * The actual CRC32 algorithm is taken from RFC 1952. + * Status: Believed complete and correct. + */ + +public class CRC32 implements Checksum +{ + int crc = 0; + + static int[] crc_table = make_crc_table(); + + /* Make the table for a fast CRC. */ + static int[] make_crc_table () + { + int[] crc_table = new int[256]; + for (int n = 0; n < 256; n++) + { + int c = n; + for (int k = 8; --k >= 0; ) + { + if ((c & 1) != 0) + c = 0xedb88320 ^ (c >>> 1); + else + c = c >>> 1; + } + crc_table[n] = c; + } + return crc_table; + } + + public long getValue () + { + return (long) crc & 0xffffffffL; + } + + public void reset () { crc = 0; } + + public void update (int bval) + { + int c = ~crc; + c = crc_table[(c ^ bval) & 0xff] ^ (c >>> 8); + crc = ~c; + } + + public void update (byte[] buf, int off, int len) + { + int c = ~crc; + while (--len >= 0) + c = crc_table[(c ^ buf[off++]) & 0xff] ^ (c >>> 8); + crc = ~c; + } + public void update (byte[] buf) { update(buf, 0, buf.length); } +} diff --git a/libjava/java/util/zip/Checksum.java b/libjava/java/util/zip/Checksum.java new file mode 100644 index 00000000000..85cdae238e0 --- /dev/null +++ b/libjava/java/util/zip/Checksum.java @@ -0,0 +1,31 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; + +/** + * @author Per Bothner + * @date January 9, 1999. + */ + +/* + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public interface Checksum +{ + public long getValue (); + + public void reset (); + + public void update (int bval); + + public void update (byte[] buf, int off, int len); +} diff --git a/libjava/java/util/zip/Deflater.java b/libjava/java/util/zip/Deflater.java new file mode 100644 index 00000000000..81312e2a84f --- /dev/null +++ b/libjava/java/util/zip/Deflater.java @@ -0,0 +1,13 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; + +public class Deflater +{ +} diff --git a/libjava/java/util/zip/DeflaterOutputStream.java b/libjava/java/util/zip/DeflaterOutputStream.java new file mode 100644 index 00000000000..4f0b8b454a5 --- /dev/null +++ b/libjava/java/util/zip/DeflaterOutputStream.java @@ -0,0 +1,46 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; +import java.io.*; + +/** JUST AN INCOMPLETE STUB! */ + +public class DeflaterOutputStream extends FilterOutputStream +{ + protected byte[] buf; + + protected Deflater def; + + public DeflaterOutputStream(OutputStream out) + { + this(out, null, 512); + } + + public DeflaterOutputStream(OutputStream out, Deflater defl) + { + this(out, defl, 512); + } + + public DeflaterOutputStream(OutputStream out, Deflater defl, int bufsize) + { + super(out); + buf = new byte[bufsize]; + def = defl; + } + + public void finish () throws IOException + { + } + + public void close () throws IOException + { + finish(); + out.close(); + } +} diff --git a/libjava/java/util/zip/ZipConstants.java b/libjava/java/util/zip/ZipConstants.java new file mode 100644 index 00000000000..4aec92e02c4 --- /dev/null +++ b/libjava/java/util/zip/ZipConstants.java @@ -0,0 +1,13 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; + +public interface ZipConstants +{ +} diff --git a/libjava/java/util/zip/ZipEntry.java b/libjava/java/util/zip/ZipEntry.java new file mode 100644 index 00000000000..d472de50cd9 --- /dev/null +++ b/libjava/java/util/zip/ZipEntry.java @@ -0,0 +1,84 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; + +/** + * @author Per Bothner + * @date January 6, 1999. + */ + +/* + * Written using on-line Java Platform 1.2 API Specification, as well + * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998). + * Status: Believed complete and correct. + */ + +public class ZipEntry +{ + // These values were determined using a simple test program. + public static final int STORED = 0; + public static final int DEFLATED = 8; + + String comment; + long compressedSize = -1; + long crc = -1; + byte[] extra; + int method = -1; + String name; + long size = -1; + long time = -1; + + ZipEntry next; + + public ZipEntry (String name) + { + this.name = name; + } + + public String getComment () { return comment; } + + public long getCompressedSize () { return compressedSize; } + + public long getCrc () { return crc; } + + public byte[] getExtra() { return extra; } + + public int getMethod () { return method; } + + public String getName () { return name; } + + public long getSize () { return size; } + + public long getTime () { return time; } + + public boolean isDirectory () + { + if (name != null) + { + int nlen = name.length(); + if (nlen > 0 && name.charAt(nlen-1) == '/') + return true; + } + return false; + } + + public void setComment (String comment) { this.comment = comment; } + + public void setCrc (long crc) { this.crc = crc; } + + public void setExtra (byte[] extra) { this.extra = extra; } + + public void setMethod(int method) { this.method = method; } + + public void setSize (long size) { this.size = size; } + + public void setTime (long time) { this.time = time; } + + public String toString () { return name; } +} diff --git a/libjava/java/util/zip/ZipException.java b/libjava/java/util/zip/ZipException.java new file mode 100644 index 00000000000..5c038a5e840 --- /dev/null +++ b/libjava/java/util/zip/ZipException.java @@ -0,0 +1,33 @@ +// ZipException.java + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libjava. + +This software is copyrighted work licensed under the terms of the +Libjava License. Please consult the file "LIBJAVA_LICENSE" for +details. */ + +package java.util.zip; + +/** + * @author Per Bothner + * @date January 9, 1999. + */ + +/* Written using on-line Java Platform 1.2 API Specification. + * Believed complete and correct. + */ + +public class ZipException extends java.io.IOException +{ + public ZipException () + { + super(); + } + + public ZipException (String msg) + { + super(msg); + } +} diff --git a/libjava/java/util/zip/ZipFile.java b/libjava/java/util/zip/ZipFile.java new file mode 100644 index 00000000000..75f0a3d94f0 --- /dev/null +++ b/libjava/java/util/zip/ZipFile.java @@ -0,0 +1,81 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; +import java.io.*; + +/** JUST AN INCOMPLETE STUB! */ + +public class ZipFile implements ZipConstants +{ + + String name; + ZipEntry entries; + + public ZipFile (String fname) throws IOException + { + name = fname; + // FIXME + } + + public ZipFile (File f) throws IOException + { + this(f.getPath()); + } + + public java.util.Enumeration entries() + { + return new ZipEnumeration(this); + } + + public void close() throws IOException + { + // FIXME + } + + public ZipEntry getEntry(String name) + { + for (ZipEntry entry = entries; entry != null; entry = entry.next) + { + if (name.equals(entry.getName())) + return entry; + } + return null; + } + + public InputStream getInputStream(ZipEntry ze) throws IOException + { + return null; // FIXME + } + + public String getName () { return name; } +} + +class ZipEnumeration implements java.util.Enumeration +{ + ZipEntry entry; + + ZipEnumeration (ZipFile zfile) + { + entry = zfile.entries; + } + + public boolean hasMoreElements () + { + return entry != null; + } + + public Object nextElement () + { + ZipEntry cur = entry; + if (cur == null) + throw new java.util.NoSuchElementException(); + entry = cur.next; + return cur; + } +} diff --git a/libjava/java/util/zip/ZipOutputStream.java b/libjava/java/util/zip/ZipOutputStream.java new file mode 100644 index 00000000000..42cfb00169e --- /dev/null +++ b/libjava/java/util/zip/ZipOutputStream.java @@ -0,0 +1,26 @@ +/* Copyright (C) 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package java.util.zip; +import java.io.*; + +/** JUST AN INCOMPLETE STUB! */ + +public class ZipOutputStream extends DeflaterOutputStream + implements ZipConstants +{ + public ZipOutputStream (OutputStream out) + { + super(out); + } + + public void putNextEntry (ZipEntry entry) throws IOException + { + throw new Error ("java.util.zip.ZipOutputStream.putNextEntry: not implemented"); + } +} diff --git a/libjava/jni.cc b/libjava/jni.cc new file mode 100644 index 00000000000..e227c03662b --- /dev/null +++ b/libjava/jni.cc @@ -0,0 +1,308 @@ +// jni.cc - JNI implementation, including the jump table. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include + +#include +#include + +static jclass +_Jv_JNI_GetSuperclass (JNIEnv *, jclass clazz) +{ + return clazz->getSuperclass (); +} + +static jboolean +IsAssignableFrom(JNIEnv *, jclass clazz1, jclass clazz2) +{ + return clazz1->isAssignableFrom (clazz2); +} + +static jobject +_Jv_JNI_GetObjectField (JNIEnv *, jobject obj, jfieldID field) +{ + return _Jv_GetObjectField (obj, field); +} + +static jbyte +_Jv_JNI_GetByteField (JNIEnv *, jobject obj, jfieldID field) +{ + return _Jv_GetByteField (obj, field); +} + +static jshort +_Jv_JNI_GetShortField (JNIEnv *, jobject obj, jfieldID field) +{ + return _Jv_GetShortField (obj, field); +} + +static jint +_Jv_JNI_GetIntField (JNIEnv *, jobject obj, jfieldID field) +{ + return _Jv_GetIntField (obj, field); +} + +static jlong +_Jv_JNI_GetLongField (JNIEnv *, jobject obj, jfieldID field) +{ + return _Jv_GetLongField (obj, field); +} + +static jsize +_Jv_JNI_GetStringLength (JNIEnv *, jstring string) +{ + return string->length(); +} + +// JDK 1.2 +jobject +_Jv_JNI_ToReflectedField (JNIEnv *, jclass cls, jfieldID fieldID) +{ + java::lang::reflect::Field *field = new java::lang::reflect::Field(); + field->declaringClass = cls; + field->offset = (char*) fieldID - (char *) cls->fields; + field->name = _Jv_NewStringUtf8Const (fieldID->getNameUtf8Const (cls)); + return field; +} + +// JDK 1.2 +jfieldID +_Jv_JNI_FromReflectedField (JNIEnv *, java::lang::reflect::Field *field) +{ + return _Jv_FromReflectedField (field); +} + +#define NOT_IMPL NULL + +struct JNINativeInterface _Jv_JNIFunctions = +{ + NULL, + NULL, + NULL, + NULL, + NOT_IMPL /* GetVersion */, + NOT_IMPL /* DefineClass */, + NOT_IMPL /* FindClass */, + NULL, + NULL, + NULL, + _Jv_JNI_GetSuperclass, + IsAssignableFrom, + NULL, + NOT_IMPL /* Throw */, + NOT_IMPL /* ThrowNew */, + NOT_IMPL /* ExceptionOccurred */, + NOT_IMPL /* ExceptionDescribe */, + NOT_IMPL /* ExceptionClear */, + NOT_IMPL /* FatalError */, + NOT_IMPL /* NULL */, + NOT_IMPL /* NULL */, + NOT_IMPL /* NewGlobalRef */, + NOT_IMPL /* DeleteGlobalRef */, + NOT_IMPL /* DeleteLocalRef */, + NOT_IMPL /* IsSameObject */, + NOT_IMPL /* NULL */, + NOT_IMPL /* NULL */, + NOT_IMPL /* AllocObject */, + NOT_IMPL /* NewObject */, + NOT_IMPL /* NewObjectV */, + NOT_IMPL /* NewObjectA */, + NOT_IMPL /* GetObjectClass */, + NOT_IMPL /* IsInstanceOf */, + NOT_IMPL /* GetMethodID */, + NOT_IMPL /* CallObjectMethod */, + NOT_IMPL /* CallObjectMethodV */, + NOT_IMPL /* CallObjectMethodA */, + NOT_IMPL /* CallBooleanMethod */, + NOT_IMPL /* CallBooleanMethodV */, + NOT_IMPL /* CallBooleanMethodA */, + NOT_IMPL /* CallByteMethod */, + NOT_IMPL /* CallByteMethodV */, + NOT_IMPL /* CallByteMethodA */, + NOT_IMPL /* CallCharMethod */, + NOT_IMPL /* CallCharMethodV */, + NOT_IMPL /* CallCharMethodA */, + NOT_IMPL /* CallShortMethod */, + NOT_IMPL /* CallShortMethodV */, + NOT_IMPL /* CallShortMethodA */, + NOT_IMPL /* CallIntMethod */, + NOT_IMPL /* CallIntMethodV */, + NOT_IMPL /* CallIntMethodA */, + NOT_IMPL /* CallLongMethod */, + NOT_IMPL /* CallLongMethodV */, + NOT_IMPL /* CallLongMethodA */, + NOT_IMPL /* CallFloatMethod */, + NOT_IMPL /* CallFloatMethodV */, + NOT_IMPL /* CallFloatMethodA */, + NOT_IMPL /* CallDoubleMethod */, + NOT_IMPL /* CallDoubleMethodV */, + NOT_IMPL /* CallDoubleMethodA */, + NOT_IMPL /* CallVoidMethod */, + NOT_IMPL /* CallVoidMethodV */, + NOT_IMPL /* CallVoidMethodA */, + NOT_IMPL /* CallNonvirtualObjectMethod */, + NOT_IMPL /* CallNonvirtualObjectMethodV */, + NOT_IMPL /* CallNonvirtualObjectMethodA */, + NOT_IMPL /* CallNonvirtualBooleanMethod */, + NOT_IMPL /* CallNonvirtualBooleanMethodV */, + NOT_IMPL /* CallNonvirtualBooleanMethodA */, + NOT_IMPL /* CallNonvirtualByteMethod */, + NOT_IMPL /* CallNonvirtualByteMethodV */, + NOT_IMPL /* CallNonvirtualByteMethodA */, + NOT_IMPL /* CallNonvirtualCharMethod */, + NOT_IMPL /* CallNonvirtualCharMethodV */, + NOT_IMPL /* CallNonvirtualCharMethodA */, + NOT_IMPL /* CallNonvirtualShortMethod */, + NOT_IMPL /* CallNonvirtualShortMethodV */, + NOT_IMPL /* CallNonvirtualShortMethodA */, + NOT_IMPL /* CallNonvirtualIntMethod */, + NOT_IMPL /* CallNonvirtualIntMethodV */, + NOT_IMPL /* CallNonvirtualIntMethodA */, + NOT_IMPL /* CallNonvirtualLongMethod */, + NOT_IMPL /* CallNonvirtualLongMethodV */, + NOT_IMPL /* CallNonvirtualLongMethodA */, + NOT_IMPL /* CallNonvirtualFloatMethod */, + NOT_IMPL /* CallNonvirtualFloatMethodV */, + NOT_IMPL /* CallNonvirtualFloatMethodA */, + NOT_IMPL /* CallNonvirtualDoubleMethod */, + NOT_IMPL /* CallNonvirtualDoubleMethodV */, + NOT_IMPL /* CallNonvirtualDoubleMethodA */, + NOT_IMPL /* CallNonvirtualVoidMethod */, + NOT_IMPL /* CallNonvirtualVoidMethodV */, + NOT_IMPL /* CallNonvirtualVoidMethodA */, + NOT_IMPL /* GetFieldID */, + _Jv_JNI_GetObjectField, + NOT_IMPL /* GetBooleanField */, + _Jv_JNI_GetByteField, + NOT_IMPL /* GetCharField */, + _Jv_JNI_GetShortField, + _Jv_JNI_GetIntField, + _Jv_JNI_GetLongField, + NOT_IMPL /* GetFloatField */, + NOT_IMPL /* GetDoubleField */, + NOT_IMPL /* SetObjectField */, + NOT_IMPL /* SetBooleanField */, + NOT_IMPL /* SetByteField */, + NOT_IMPL /* SetCharField */, + NOT_IMPL /* SetShortField */, + NOT_IMPL /* SetIntField */, + NOT_IMPL /* SetLongField */, + NOT_IMPL /* SetFloatField */, + NOT_IMPL /* SetDoubleField */, + NOT_IMPL /* GetStaticMethodID */, + NOT_IMPL /* CallStaticObjectMethod */, + NOT_IMPL /* CallStaticObjectMethodV */, + NOT_IMPL /* CallStaticObjectMethodA */, + NOT_IMPL /* CallStaticBooleanMethod */, + NOT_IMPL /* CallStaticBooleanMethodV */, + NOT_IMPL /* CallStaticBooleanMethodA */, + NOT_IMPL /* CallStaticByteMethod */, + NOT_IMPL /* CallStaticByteMethodV */, + NOT_IMPL /* CallStaticByteMethodA */, + NOT_IMPL /* CallStaticCharMethod */, + NOT_IMPL /* CallStaticCharMethodV */, + NOT_IMPL /* CallStaticCharMethodA */, + NOT_IMPL /* CallStaticShortMethod */, + NOT_IMPL /* CallStaticShortMethodV */, + NOT_IMPL /* CallStaticShortMethodA */, + NOT_IMPL /* CallStaticIntMethod */, + NOT_IMPL /* CallStaticIntMethodV */, + NOT_IMPL /* CallStaticIntMethodA */, + NOT_IMPL /* CallStaticLongMethod */, + NOT_IMPL /* CallStaticLongMethodV */, + NOT_IMPL /* CallStaticLongMethodA */, + NOT_IMPL /* CallStaticFloatMethod */, + NOT_IMPL /* CallStaticFloatMethodV */, + NOT_IMPL /* CallStaticFloatMethodA */, + NOT_IMPL /* CallStaticDoubleMethod */, + NOT_IMPL /* CallStaticDoubleMethodV */, + NOT_IMPL /* CallStaticDoubleMethodA */, + NOT_IMPL /* CallStaticVoidMethod */, + NOT_IMPL /* CallStaticVoidMethodV */, + NOT_IMPL /* CallStaticVoidMethodA */, + NOT_IMPL /* GetStaticFieldID */, + NOT_IMPL /* GetStaticObjectField */, + NOT_IMPL /* GetStaticBooleanField */, + NOT_IMPL /* GetStaticByteField */, + NOT_IMPL /* GetStaticCharField */, + NOT_IMPL /* GetStaticShortField */, + NOT_IMPL /* GetStaticIntField */, + NOT_IMPL /* GetStaticLongField */, + NOT_IMPL /* GetStaticFloatField */, + NOT_IMPL /* GetStaticDoubleField */, + NOT_IMPL /* SetStaticObjectField */, + NOT_IMPL /* SetStaticBooleanField */, + NOT_IMPL /* SetStaticByteField */, + NOT_IMPL /* SetStaticCharField */, + NOT_IMPL /* SetStaticShortField */, + NOT_IMPL /* SetStaticIntField */, + NOT_IMPL /* SetStaticLongField */, + NOT_IMPL /* SetStaticFloatField */, + NOT_IMPL /* SetStaticDoubleField */, + NOT_IMPL /* NewString */, + _Jv_JNI_GetStringLength, + NOT_IMPL /* GetStringChars */, + NOT_IMPL /* ReleaseStringChars */, + NOT_IMPL /* NewStringUTF */, + NOT_IMPL /* GetStringUTFLength */, + NOT_IMPL /* GetStringUTFChars */, + NOT_IMPL /* ReleaseStringUTFChars */, + NOT_IMPL /* GetArrayLength */, + NOT_IMPL /* NewObjectArray */, + NOT_IMPL /* GetObjectArrayElement */, + NOT_IMPL /* SetObjectArrayElement */, + NOT_IMPL /* NewBooleanArray */, + NOT_IMPL /* NewByteArray */, + NOT_IMPL /* NewCharArray */, + NOT_IMPL /* NewShortArray */, + NOT_IMPL /* NewIntArray */, + NOT_IMPL /* NewLongArray */, + NOT_IMPL /* NewFloatArray */, + NOT_IMPL /* NewDoubleArray */, + NOT_IMPL /* GetBooleanArrayElements */, + NOT_IMPL /* GetByteArrayElements */, + NOT_IMPL /* GetCharArrayElements */, + NOT_IMPL /* GetShortArrayElements */, + NOT_IMPL /* GetIntArrayElements */, + NOT_IMPL /* GetLongArrayElements */, + NOT_IMPL /* GetFloatArrayElements */, + NOT_IMPL /* GetDoubleArrayElements */, + NOT_IMPL /* ReleaseBooleanArrayElements */, + NOT_IMPL /* ReleaseByteArrayElements */, + NOT_IMPL /* ReleaseCharArrayElements */, + NOT_IMPL /* ReleaseShortArrayElements */, + NOT_IMPL /* ReleaseIntArrayElements */, + NOT_IMPL /* ReleaseLongArrayElements */, + NOT_IMPL /* ReleaseFloatArrayElements */, + NOT_IMPL /* ReleaseDoubleArrayElements */, + NOT_IMPL /* GetBooleanArrayRegion */, + NOT_IMPL /* GetByteArrayRegion */, + NOT_IMPL /* GetCharArrayRegion */, + NOT_IMPL /* GetShortArrayRegion */, + NOT_IMPL /* GetIntArrayRegion */, + NOT_IMPL /* GetLongArrayRegion */, + NOT_IMPL /* GetFloatArrayRegion */, + NOT_IMPL /* GetDoubleArrayRegion */, + NOT_IMPL /* SetBooleanArrayRegion */, + NOT_IMPL /* SetByteArrayRegion */, + NOT_IMPL /* SetCharArrayRegion */, + NOT_IMPL /* SetShortArrayRegion */, + NOT_IMPL /* SetIntArrayRegion */, + NOT_IMPL /* SetLongArrayRegion */, + NOT_IMPL /* SetFloatArrayRegion */, + NOT_IMPL /* SetDoubleArrayRegion */, + NOT_IMPL /* RegisterNatives */, + NOT_IMPL /* UnregisterNatives */, + NOT_IMPL /* MonitorEnter */, + NOT_IMPL /* MonitorExit */, + NOT_IMPL /* GetJavaVM */, +}; diff --git a/libjava/no-threads.cc b/libjava/no-threads.cc new file mode 100644 index 00000000000..d6e0298d219 --- /dev/null +++ b/libjava/no-threads.cc @@ -0,0 +1,26 @@ +// no-thread.cc - Implementation of `no threads' threads. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include +#include + +java::lang::Thread *_Jv_OnlyThread = NULL; + +void +_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *, + _Jv_ThreadStartFunc *meth) +{ + JvAssert (! _Jv_OnlyThread); + _Jv_OnlyThread = thread; + (*meth) (thread); +} diff --git a/libjava/nogc.cc b/libjava/nogc.cc new file mode 100644 index 00000000000..2d3676bdcca --- /dev/null +++ b/libjava/nogc.cc @@ -0,0 +1,81 @@ +// nogc.cc - Code to implement no GC. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include + +#include +#include + +// Total amount of memory allocated. +static long total = 0; + +void * +_Jv_AllocObj (jsize size) +{ + total += size; + return calloc (size, 1); +} + +void * +_Jv_AllocArray (jsize size) +{ + total += size; + return calloc (size, 1); +} + +void * +_Jv_AllocBytes (jsize size) +{ + total += size; + return calloc (size, 1); +} + +void +_Jv_RegisterFinalizer (void *, _Jv_FinalizerFunc *) +{ + // FIXME: should actually register so that finalizers can be run on + // exit. +} + +void +_Jv_RunFinalizers (void) +{ +} + +void +_Jv_RunAllFinalizers (void) +{ + // FIXME: should still run all finalizers. +} + +void +_Jv_RunGC (void) +{ +} + +long +_Jv_GCTotalMemory (void) +{ + return total; +} + +long +_Jv_GCFreeMemory (void) +{ + return 0; +} + +void +_Jv_InitGC (void) +{ +} diff --git a/libjava/posix-threads.cc b/libjava/posix-threads.cc new file mode 100644 index 00000000000..436588aee32 --- /dev/null +++ b/libjava/posix-threads.cc @@ -0,0 +1,360 @@ +// posix-threads.cc - interface between libjava and POSIX threads. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +// TO DO: +// * Document signal handling limitations + +#include + +// If we're using the Boehm GC, then we need to override some of the +// thread primitives. This is fairly gross. +#ifdef HAVE_BOEHM_GC +extern "C" +{ +#include +#include +}; +#endif /* HAVE_BOEHM_GC */ + +#include +#include +#include + +#include +#include +#include +#include + +// This is used to implement thread startup. +struct starter +{ + _Jv_ThreadStartFunc *method; + java::lang::Thread *object; + _Jv_Thread_t *data; +}; + +// This is the key used to map from the POSIX thread value back to the +// Java object representing the thread. The key is global to all +// threads, so it is ok to make it a global here. +pthread_key_t _Jv_ThreadKey; + +// We keep a count of all non-daemon threads which are running. When +// this reaches zero, _Jv_ThreadWait returns. +static pthread_mutex_t daemon_mutex; +static pthread_cond_t daemon_cond; +static int non_daemon_count; + +// The signal to use when interrupting a thread. +#ifdef LINUX_THREADS + // LinuxThreads usurps both SIGUSR1 and SIGUSR2. +# define INTR SIGHUP +#else /* LINUX_THREADS */ +# define INTR SIGUSR2 +#endif /* LINUX_THREADS */ + +// +// These are the flags that can appear in _Jv_Thread_t. +// + +// Thread started. +#define FLAG_START 0x01 +// Thread is daemon. +#define FLAG_DAEMON 0x02 + + + +int +_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, + jlong millis, jint nanos) +{ + int r; + pthread_mutex_t *pmu; +#ifdef HAVE_RECURSIVE_MUTEX + pmu = mu; +#else + pmu = &mu->mutex2; +#endif + if (millis == 0 && nanos == 0) + r = pthread_cond_wait (cv, pmu); + else + { + struct timespec ts; + unsigned long m = millis + java::lang::System::currentTimeMillis (); + + ts.tv_sec = m / 1000; + ts.tv_nsec = (m % 1000) * 1000 * 1000 + nanos; + + r = pthread_cond_timedwait (cv, pmu, &ts); + } + return r; +} + +#ifndef RECURSIVE_MUTEX_IS_DEFAULT + +void +_Jv_MutexInit (_Jv_Mutex_t *mu) +{ +#ifdef HAVE_RECURSIVE_MUTEX + pthread_mutexattr_t *val = NULL; + +#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) + pthread_mutexattr_t attr; + + // If this is slow, then allocate it statically and only initialize + // it once. + pthread_mutexattr_init (&attr); + pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE); + val = &attr; +#elif defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP) + pthread_mutexattr_t attr; + pthread_mutexattr_init (&attr); + pthread_mutexattr_setkind_np (&attr, PTHREAD_MUTEX_RECURSIVE_NP); + val = &attr; +#endif + + pthread_mutex_init (mu, val); + +#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) || defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP) + pthread_mutexattr_destroy (&attr); +#endif + +#else /* HAVE_RECURSIVE_MUTEX */ + + // No recursive mutex, so simulate one. + pthread_mutex_init (&mu->mutex, NULL); + pthread_mutex_init (&mu->mutex2, NULL); + pthread_cond_init (&mu->cond, 0); + mu->count = 0; + +#endif /* HAVE_RECURSIVE_MUTEX */ +} + +#endif /* not RECURSIVE_MUTEX_IS_DEFAULT */ + +#if ! defined (LINUX_THREADS) && ! defined (HAVE_RECURSIVE_MUTEX) + +void +_Jv_MutexDestroy (_Jv_Mutex_t *mu) +{ + pthread_mutex_destroy (&mu->mutex); + pthread_mutex_destroy (&mu->mutex2); + pthread_cond_destroy (&mu->cond); +} + +int +_Jv_MutexLock (_Jv_Mutex_t *mu) +{ + if (pthread_mutex_lock (&mu->mutex)) + return -1; + while (1) + { + if (mu->count == 0) + { + // Grab the lock. + mu->thread = pthread_self (); + mu->count = 1; + pthread_mutex_lock (&mu->mutex2); + break; + } + else if (pthread_self () == mu->thread) + { + // Already have the lock. + mu->count += 1; + break; + } + else + { + // Try to acquire the lock. + pthread_cond_wait (&mu->cond, &mu->mutex); + } + } + pthread_mutex_unlock (&mu->mutex); + return 0; +} + +int +_Jv_MutexUnlock (_Jv_Mutex_t *mu) +{ + if (pthread_mutex_lock (&mu->mutex)) + return -1; + int r = 0; + if (mu->count == 0 || pthread_self () != mu->thread) + r = -1; + else + { + mu->count -= 1; + if (! mu->count) + { + pthread_mutex_unlock (&mu->mutex2); + pthread_cond_signal (&mu->cond); + } + } + pthread_mutex_unlock (&mu->mutex); + return r; +} + +#endif /* not LINUX_THREADS and not HAVE_RECURSIVE_MUTEX */ + +static void +handle_intr (int) +{ + // Do nothing. +} + +void +_Jv_InitThreads (void) +{ + pthread_key_create (&_Jv_ThreadKey, NULL); + pthread_mutex_init (&daemon_mutex, NULL); + pthread_cond_init (&daemon_cond, 0); + non_daemon_count = 0; + + // Arrange for the interrupt signal to interrupt system calls. + struct sigaction act; + act.sa_handler = handle_intr; + sigemptyset (&act.sa_mask); + act.sa_flags = 0; + sigaction (INTR, &act, NULL); + + // Arrange for SIGINT to be blocked to all threads. It is only + // deliverable to the master thread. + sigset_t mask; + sigemptyset (&mask); + sigaddset (&mask, SIGINT); + pthread_sigmask (SIG_BLOCK, &mask, NULL); +} + +void +_Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *) +{ + _Jv_Thread_t *info = new _Jv_Thread_t; + + info->flags = 0; + info->exception = NULL; + + // FIXME register a finalizer for INFO here. + // FIXME also must mark INFO somehow. + + *data = info; +} + +void +_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio) +{ + if (data->flags & FLAG_START) + { + struct sched_param param; + + param.sched_priority = prio; + pthread_setschedparam (data->thread, SCHED_RR, ¶m); + } +} + + +// This is called as a cleanup handler when a thread is exiting. We +// use it to throw the requested exception. It's entirely possible +// that this approach is doomed to failure, in which case we'll need +// to adopt some alternate. For instance, use a signal to implement +// _Jv_ThreadCancel. +static void +throw_cleanup (void *data) +{ + _Jv_Thread_t *td = (_Jv_Thread_t *) data; + _Jv_Throw ((java::lang::Throwable *) td->exception); +} + +void +_Jv_ThreadCancel (_Jv_Thread_t *data, void *error) +{ + data->exception = error; + pthread_cancel (data->thread); +} + +// This function is called when a thread is started. We don't arrange +// to call the `run' method directly, because this function must +// return a value. +static void * +really_start (void *x) +{ + struct starter *info = (struct starter *) x; + + pthread_cleanup_push (throw_cleanup, info->data); + pthread_setspecific (_Jv_ThreadKey, info->object); + info->method (info->object); + pthread_cleanup_pop (0); + + if (! (info->data->flags & FLAG_DAEMON)) + { + pthread_mutex_lock (&daemon_mutex); + --non_daemon_count; + if (! non_daemon_count) + pthread_cond_signal (&daemon_cond); + pthread_mutex_unlock (&daemon_mutex); + } + + return NULL; +} + +void +_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data, + _Jv_ThreadStartFunc *meth) +{ + struct sched_param param; + pthread_attr_t attr; + struct starter *info; + + if (data->flags & FLAG_START) + return; + data->flags |= FLAG_START; + + param.sched_priority = thread->getPriority(); + + pthread_attr_init (&attr); + pthread_attr_setschedparam (&attr, ¶m); + + // FIXME: handle marking the info object for GC. + info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter)); + info->method = meth; + info->object = thread; + info->data = data; + + if (! thread->isDaemon()) + { + pthread_mutex_lock (&daemon_mutex); + ++non_daemon_count; + pthread_mutex_unlock (&daemon_mutex); + } + else + data->flags |= FLAG_DAEMON; + pthread_create (&data->thread, &attr, really_start, (void *) info); + + pthread_attr_destroy (&attr); +} + +void +_Jv_ThreadWait (void) +{ + // Arrange for SIGINT to be delivered to the master thread. + sigset_t mask; + sigemptyset (&mask); + sigaddset (&mask, SIGINT); + pthread_sigmask (SIG_UNBLOCK, &mask, NULL); + + pthread_mutex_lock (&daemon_mutex); + if (non_daemon_count) + pthread_cond_wait (&daemon_cond, &daemon_mutex); + pthread_mutex_unlock (&daemon_mutex); +} + +void +_Jv_ThreadInterrupt (_Jv_Thread_t *data) +{ + pthread_kill (data->thread, INTR); +} diff --git a/libjava/prims.cc b/libjava/prims.cc new file mode 100644 index 00000000000..265e281dcb1 --- /dev/null +++ b/libjava/prims.cc @@ -0,0 +1,602 @@ +// prims.cc - Code for core of runtime environment. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include +#include +#include +#ifdef HANDLE_SEGV +#include +#endif + +#pragma implementation "java-array.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define ObjectClass _CL_Q34java4lang6Object +extern java::lang::Class ObjectClass; + +// We allocate a single OutOfMemoryError exception which we keep +// around for use if we run out of memory. +static java::lang::OutOfMemoryError *no_memory; + +// Largest representable size_t. +#define SIZE_T_MAX ((size_t) (~ (size_t) 0)) + + + +jboolean +_Jv_equalUtf8Consts (Utf8Const* a, Utf8Const *b) +{ + register int len; + register _Jv_ushort *aptr, *bptr; + if (a == b) + return true; + if (a->hash != b->hash) + return false; + len = a->length; + if (b->length != len) + return false; + aptr = (_Jv_ushort *)a->data; + bptr = (_Jv_ushort *)b->data; + len = (len + 1) >> 1; + while (--len >= 0) + if (*aptr++ != *bptr++) + return false; + return true; +} + +/* True iff A is equal to STR. + HASH is STR->hashCode(). +*/ + +jboolean +_Jv_equal (Utf8Const* a, jstring str, jint hash) +{ + if (a->hash != (_Jv_ushort) hash) + return false; + jint len = str->length(); + jint i = 0; + jchar *sptr = _Jv_GetStringChars (str); + register unsigned char* ptr = (unsigned char*) a->data; + register unsigned char* limit = ptr + a->length; + for (;; i++, sptr++) + { + int ch = UTF8_GET (ptr, limit); + if (i == len) + return ch < 0; + if (ch != *sptr) + return false; + } + return true; +} + +/* Count the number of Unicode chars encoded in a given Ut8 string. */ +int +_Jv_strLengthUtf8(char* str, int len) +{ + register unsigned char* ptr; + register unsigned char* limit; + int str_length; + + ptr = (unsigned char*) str; + limit = ptr + len; + str_length = 0; + for (; ptr < limit; str_length++) { + if (UTF8_GET (ptr, limit) < 0) { + return (-1); + } + } + return (str_length); +} + +/* Calculate a hash value for a string encoded in Utf8 format. + * This returns the same hash value as specified or java.lang.String.hashCode. + */ +static jint +hashUtf8String (char* str, int len) +{ + register unsigned char* ptr = (unsigned char*) str; + register unsigned char* limit = ptr + len; + jint hash = 0; + + for (; ptr < limit;) + { + int ch = UTF8_GET (ptr, limit); + /* Updated specification from + http://www.javasoft.com/docs/books/jls/clarify.html. */ + hash = (31 * hash) + ch; + } + return hash; +} + +_Jv_Utf8Const * +_Jv_makeUtf8Const (char* s, int len) +{ + if (len < 0) + len = strlen (s); + Utf8Const* m = (Utf8Const*) _Jv_AllocBytes (sizeof(Utf8Const) + len + 1); + if (! m) + JvThrow (no_memory); + memcpy (m->data, s, len); + m->data[len] = 0; + m->length = len; + m->hash = hashUtf8String (s, len) & 0xFFFF; + return (m); +} + + + +#ifdef DEBUG +void +_Jv_Abort (const char *function, const char *file, int line, + const char *message) +#else +void +_Jv_Abort (const char *, const char *, int, const char *message) +#endif +{ +#ifdef DEBUG + fprintf (stderr, + "libgcj failure: %s\n in function %s, file %s, line %d\n", + message, function, file, line); +#else + java::io::PrintStream *err = java::lang::System::err; + err->print(JvNewStringLatin1 ("libgcj failure: ")); + err->println(JvNewStringLatin1 (message)); + err->flush(); +#endif + abort (); +} + +static void +fail_on_finalization (jobject) +{ + JvFail ("object was finalized"); +} + +void +_Jv_GCWatch (jobject obj) +{ + _Jv_RegisterFinalizer (obj, fail_on_finalization); +} + +void +_Jv_ThrowBadArrayIndex(jint bad_index) +{ + JvThrow (new java::lang::ArrayIndexOutOfBoundsException + (java::lang::String::valueOf(bad_index))); +} + +void* +_Jv_CheckCast (jclass c, jobject obj) +{ + if (obj != NULL && ! c->isAssignableFrom(obj->getClass())) + JvThrow (new java::lang::ClassCastException); + return obj; +} + +void +_Jv_CheckArrayStore (jobject arr, jobject obj) +{ + if (obj) + { + JvAssert (arr != NULL); + jclass arr_class = arr->getClass(); + JvAssert (arr_class->isArray()); + jclass elt_class = arr_class->getComponentType(); + jclass obj_class = obj->getClass(); + if (! elt_class->isAssignableFrom(obj_class)) + JvThrow (new java::lang::ArrayStoreException); + } +} + + + +// Allocate some unscanned memory and throw an exception if no memory. +void * +_Jv_AllocBytesChecked (jsize size) +{ + void *r = _Jv_AllocBytes (size); + if (! r) + _Jv_Throw (no_memory); + return r; +} + +// Allocate a new object of class C. SIZE is the size of the object +// to allocate. You might think this is redundant, but it isn't; some +// classes, such as String, aren't of fixed size. +jobject +_Jv_AllocObject (jclass c, jint size) +{ + _Jv_InitClass (c); + + jobject obj = (jobject) _Jv_AllocObj (size); + if (! obj) + JvThrow (no_memory); + *((_Jv_VTable **) obj) = c->vtable; + + // If this class has inherited finalize from Object, then don't + // bother registering a finalizer. We know that finalize() is the + // very first method after the dummy entry. If this turns out to be + // unreliable, a more robust implementation can be written. Such an + // implementation would look for Object.finalize in Object's method + // table at startup, and then use that information to find the + // appropriate index in the method vector. + if (c->vtable->method[1] != ObjectClass.vtable->method[1]) + _Jv_RegisterFinalizer (obj, _Jv_FinalizeObject); + + return obj; +} + +// Allocate a new array of Java objects. Each object is of type +// `elementClass'. `init' is used to initialize each slot in the +// array. +jobjectArray +_Jv_NewObjectArray (jsize count, jclass elementClass, jobject init) +{ + if (count < 0) + JvThrow (new java::lang::NegativeArraySizeException); + + // Check for overflow. + if ((size_t) count > (SIZE_T_MAX - sizeof (__JArray)) / sizeof (jobject)) + JvThrow (no_memory); + + size_t size = count * sizeof (jobject) + sizeof (__JArray); + jclass clas = _Jv_FindArrayClass (elementClass); + jobjectArray obj = (jobjectArray) _Jv_AllocArray (size); + if (! obj) + JvThrow (no_memory); + obj->length = count; + jobject* ptr = elements(obj); + // We know the allocator returns zeroed memory. So don't bother + // zeroing it again. + if (init) + { + while (--count >= 0) + *ptr++ = init; + } + // Set the vtbl last to avoid problems if the GC happens during the + // window in this function between the allocation and this + // assignment. + *((_Jv_VTable **) obj) = clas->vtable; + return obj; +} + +// Allocate a new array of primitives. ELTYPE is the type of the +// element, COUNT is the size of the array. +jobject +_Jv_NewPrimArray (jclass eltype, jint count) +{ + int elsize = eltype->size(); + if (count < 0) + JvThrow (new java::lang::NegativeArraySizeException ()); + + // Check for overflow. + if ((size_t) count > (SIZE_T_MAX - sizeof (__JArray)) / elsize) + JvThrow (no_memory); + + __JArray *arr = (__JArray*) _Jv_AllocObj (sizeof (__JArray) + + elsize * count); + if (! arr) + JvThrow (no_memory); + arr->length = count; + // Note that we assume we are given zeroed memory by the allocator. + + jclass klass = _Jv_FindArrayClass (eltype); + // Set the vtbl last to avoid problems if the GC happens during the + // window in this function between the allocation and this + // assignment. + *((_Jv_VTable **) arr) = klass->vtable; + return arr; +} + +jcharArray +JvNewCharArray (jint length) +{ + return (jcharArray) _Jv_NewPrimArray (JvPrimClass (char), length); +} + +jbooleanArray +JvNewBooleanArray (jint length) +{ + return (jbooleanArray) _Jv_NewPrimArray (JvPrimClass (boolean), length); +} + +jbyteArray +JvNewByteArray (jint length) +{ + return (jbyteArray) _Jv_NewPrimArray (JvPrimClass (byte), length); +} + +jshortArray +JvNewShortArray (jint length) +{ + return (jshortArray) _Jv_NewPrimArray (JvPrimClass (short), length); +} + +jintArray +JvNewIntArray (jint length) +{ + return (jintArray) _Jv_NewPrimArray (JvPrimClass (int), length); +} + +jlongArray +JvNewLongArray (jint length) +{ + return (jlongArray) _Jv_NewPrimArray (JvPrimClass (long), length); +} + +jfloatArray +JvNewFloatArray (jint length) +{ + return (jfloatArray) _Jv_NewPrimArray (JvPrimClass (float), length); +} + +jdoubleArray +JvNewDoubleArray (jint length) +{ + return (jdoubleArray) _Jv_NewPrimArray (JvPrimClass (double), length); +} + +jobject +_Jv_NewArray (jint type, jint size) +{ + switch (type) + { + case 4: return JvNewBooleanArray (size); + case 5: return JvNewCharArray (size); + case 6: return JvNewFloatArray (size); + case 7: return JvNewDoubleArray (size); + case 8: return JvNewByteArray (size); + case 9: return JvNewShortArray (size); + case 10: return JvNewIntArray (size); + case 11: return JvNewLongArray (size); + } + JvFail ("newarray - bad type code"); + return NULL; // Placate compiler. +} + +jobject +_Jv_NewMultiArray (jclass type, jint dimensions, jint *sizes) +{ + JvAssert (type->isArray()); + jclass element_type = type->getComponentType(); + jobject result; + if (element_type->isPrimitive()) + result = _Jv_NewPrimArray (element_type, sizes[0]); + else + result = _Jv_NewObjectArray (sizes[0], element_type, NULL); + + if (dimensions > 1) + { + JvAssert (! element_type->isPrimitive()); + JvAssert (element_type->isArray()); + jobject *contents = elements ((jobjectArray) result); + for (int i = 0; i < sizes[0]; ++i) + contents[i] = _Jv_NewMultiArray (element_type, dimensions - 1, + sizes + 1); + } + + return result; +} + +jobject +_Jv_NewMultiArray (jclass array_type, jint dimensions, ...) +{ + va_list args; + jint sizes[dimensions]; + va_start (args, dimensions); + for (int i = 0; i < dimensions; ++i) + { + jint size = va_arg (args, jint); + sizes[i] = size; + } + va_end (args); + + return _Jv_NewMultiArray (array_type, dimensions, sizes); +} + + + +#ifdef HANDLE_SEGV + +static java::lang::NullPointerException *nullp; + +static void +catch_segv (int) +{ + // Don't run `new' in a signal handler, so we always throw the same + // null pointer exception. + _Jv_Throw (nullp); +} + +#endif /* HANDLE_SEGV */ + +class _Jv_PrimClass : public java::lang::Class +{ +public: + // FIXME: calling convention is weird. If we use the natural types + // then the compiler will complain because they aren't Java types. + _Jv_PrimClass (jobject cname, jbyte sig, jint len) + { + using namespace java::lang::reflect; + + // We must initialize every field of the class. We do this in + // the same order they are declared in Class.h. + next = NULL; + name = _Jv_makeUtf8Const ((char *) cname, -1); + accflags = Modifier::PUBLIC | Modifier::FINAL; + superclass = NULL; + constants.size = 0; + constants.tags = NULL; + constants.data = NULL; + methods = NULL; + method_count = sig; + vtable_method_count = 0; + fields = NULL; + size_in_bytes = len; + field_count = 0; + static_field_count = 0; + vtable = JV_PRIMITIVE_VTABLE; + interfaces = NULL; + loader = NULL; + interface_count = 0; + state = 0; // FIXME. + thread = NULL; + } +}; + +#define DECLARE_PRIM_TYPE(NAME, SIG, LEN) \ + _Jv_PrimClass _Jv_##NAME##Class((jobject) #NAME, (jbyte) SIG, (jint) LEN) + +DECLARE_PRIM_TYPE(byte, 'B', 1); +DECLARE_PRIM_TYPE(short, 'S', 2); +DECLARE_PRIM_TYPE(int, 'I', 4); +DECLARE_PRIM_TYPE(long, 'J', 8); +DECLARE_PRIM_TYPE(boolean, 'Z', 1); +DECLARE_PRIM_TYPE(char, 'C', 2); +DECLARE_PRIM_TYPE(float, 'F', 4); +DECLARE_PRIM_TYPE(double, 'D', 8); +DECLARE_PRIM_TYPE(void, 'V', 0); + +jclass +_Jv_FindClassFromSignature (char *sig, java::lang::ClassLoader *loader) +{ + switch (*sig) + { + case 'B': + return JvPrimClass (byte); + case 'S': + return JvPrimClass (short); + case 'I': + return JvPrimClass (int); + case 'J': + return JvPrimClass (long); + case 'Z': + return JvPrimClass (boolean); + case 'C': + return JvPrimClass (char); + case 'F': + return JvPrimClass (float); + case 'D': + return JvPrimClass (double); + case 'V': + return JvPrimClass (void); + case 'L': + { + int i; + for (i = 1; sig[i] && sig[i] != ';'; ++i) + ; + _Jv_Utf8Const *name = _Jv_makeUtf8Const (&sig[1], i - 1); + return _Jv_FindClass (name, loader); + } + case '[': + return _Jv_FindArrayClass (_Jv_FindClassFromSignature (&sig[1], loader)); + } + JvFail ("couldn't understand class signature"); + return NULL; // Placate compiler. +} + + + +JArray * +JvConvertArgv (int argc, const char **argv) +{ + if (argc < 0) + argc = 0; + jobjectArray ar = JvNewObjectArray(argc, &StringClass, NULL); + jobject* ptr = elements(ar); + for (int i = 0; i < argc; i++) + { + const char *arg = argv[i]; + // FIXME - should probably use JvNewStringUTF. + *ptr++ = JvNewStringLatin1(arg, strlen(arg)); + } + return (JArray*) ar; +} + +// FIXME: These variables are static so that they will be +// automatically scanned by the Boehm collector. This is needed +// because with qthreads the collector won't scan the initial stack -- +// it will only scan the qthreads stacks. + +// Command line arguments. +static jobject arg_vec; + +// The primary threadgroup. +static java::lang::ThreadGroup *main_group; + +// The primary thread. +static java::lang::Thread *main_thread; + +void +JvRunMain (jclass klass, int argc, const char **argv) +{ +#ifdef HANDLE_SEGV + nullp = new java::lang::NullPointerException (); + + struct sigaction act; + act.sa_handler = catch_segv; + sigemptyset (&act.sa_mask); + act.sa_flags = 0; + sigaction (SIGSEGV, &act, NULL); +#endif + + no_memory = new java::lang::OutOfMemoryError; + + arg_vec = JvConvertArgv (argc - 1, argv + 1); + main_group = new java::lang::ThreadGroup (23); + main_thread = new java::lang::FirstThread (main_group, klass, arg_vec); + + main_thread->start(); + _Jv_ThreadWait (); + + java::lang::Runtime::getRuntime ()->exit (0); +} + + + +void * +_Jv_Malloc (jsize size) +{ + if (size == 0) + size = 1; + void *ptr = malloc ((size_t) size); + if (ptr == NULL) + JvThrow (no_memory); + return ptr; +} + +void +_Jv_Free (void* ptr) +{ + return free (ptr); +} diff --git a/libjava/quick-threads.cc b/libjava/quick-threads.cc new file mode 100644 index 00000000000..ed7ac5eac7b --- /dev/null +++ b/libjava/quick-threads.cc @@ -0,0 +1,51 @@ +// quick-threads.cc - interface between libjava and QuickThreads. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include + +#include +#include + +#include +#include + + +// Identifier for our piece of thread-local data. Visible so that it +// can be used in quick-threads.h. +int _Jv_ThreadKey; + +void +_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data, + _Jv_ThreadStartFunc *meth) +{ + *data = coop_create ((coop_userf_t *) meth, (void *) thread, + thread->isDaemon()); + coop_setspecific (*data, _Jv_ThreadKey, thread); +} + +static void +qthrow (void *except) +{ + _Jv_Throw ((java::lang::Throwable *) except); +} + +// Function to destroy thread-specific data item. We just don't care. +static void +destroy_data (void *) +{ +} + +void +_Jv_InitThreads (void) +{ + coop_init (); + _Jv_ThreadKey = coop_key_create (destroy_data); + coop_set_throw_function (qthrow); +} diff --git a/libjava/testsuite/ChangeLog b/libjava/testsuite/ChangeLog new file mode 100644 index 00000000000..d7559a238b8 --- /dev/null +++ b/libjava/testsuite/ChangeLog @@ -0,0 +1,326 @@ +1999-04-06 Tom Tromey + + * libjava.mauve/mauve.exp (test_mauve_sim): Reference + mauve-libgcj. + (test_mauve): Likewise. + +1999-03-30 Tom Tromey + + * libjava.mauve/mauve.exp: Renamed from test.exp. With the new + name it is easier to run just the Mauve tests. + + * libjava.mauve/test.exp (test_mauve): Added gnu/testlet/config to + list of files to link in. + (test_mauve_sim): Likewise. + * libjava.mauve/DejaGNUTestHarness.java (srcdir, tmpdir): New + static variables. + (DejaGNUTestHarness): Removed argument from constructor. + (dejasrcdir): New static variable. + (main): Set `dejasrcdir'. + (getSourceDirectory): New method. + +1999-03-08 Tom Tromey + + * libjava.compile/perc.java: New file. + +1999-02-26 Tom Tromey + + * libjava.util/test.exp: Removed. + +1999-02-25 Tom Tromey + + * libjava.mauve/test.exp: Make sure current directory is correct + after tests are run. + + * libjava.mauve/test.exp (test_mauve): Removed extra arg in call + to bytecompile_file. + (test_mauve_sim): Likewise. + +Thu Feb 25 09:21:03 1999 Anthony Green + + * libjava.compile/euc_comment1.java, + libjava.compile/euc_comment2.java, + libjava.compile/euc_comment3.java, + libjava.compile/euc_comment1.java, + libjava.compile/euc_comment2.java, + libjava.compile/euc_comment3.java: New files. + + * libjava.compile/Case.java, libjava.compile/support/Case.java: + New files. + +1999-02-24 Tom Tromey + + * lib/libjava.exp (find_jvscan): New proc. + (bytecompile_file): Removed `srcfile_in' argument. + (test_libjava_from_javac): Use `jv-scan' program to find name of + `main' and name of all generated classes. Compile all generated + classes, not just primary class. For no-exec tests, only try to + build the .o, not the full executable. + +Wed Feb 24 11:22:32 1999 Anthony Green + + * libjava.compile/test.exp: Minor fix. + +1999-02-23 Anthony Green + + * libjava.compile/Where.java, libjava.compile/support/Waldo.java, + libjava.compile/Twice.java, libjava.compile/Semi.java, + libjava.compile/Statics.java, libjava.compile/test.exp, + libjava.lang/Synch.java, libjava.lang/Synch.out: New files. + +1999-02-16 Tom Tromey + + * Makefile.in: Rebuilt. + * Makefile.am (AUTOMAKE_OPTIONS): Added no-installinfo. + +Wed Feb 17 19:53:51 1999 Warren Levy + + * libjava.mauve/test.exp: modified file allows Mauve tests to + run on JMR board; simplified script to use same procedure for + all testing + +1999-02-10 Tom Tromey + + * lib/libjava.exp (libjava_arguments): Updated to track library + renames. + +1999-02-07 Tom Tromey + + * libjava.lang/slash.java: New file. + * libjava.lang/slash.out: New file. + +Mon Feb 1 05:17:40 1999 Anthony Green + + * lib/libjava.exp: Test compiling from source as well as from + bytecodes. + +1999-01-11 Tom Tromey + + * libjava.mauve/test.exp (mauve_compute_uses): Read classes file, + not choices file. + + * libjava.mauve/test.exp (test_mauve): Added + ResourceNotFoundException to list of harness files to compile. + (test_mauve_sim): Likewise. + +1998-12-17 Tom Tromey + + * libjava.lang/Invoke_1.java: New file. + + * libjava.lang/Thread_1.java (Thread_1): Class now public. + * libjava.lang/Array_1.java (Array_1): Class now public. + + * libjava.lang/Throw_1.out: New file. + * libjava.lang/Throw_1.java: New file. + +1998-12-11 Tom Tromey + + * lib/libjava.exp (libjava_arguments): New proc. + (test_libjava): Use it. + (bytecompile_file): Added classpath argument. + * libjava.mauve/test.exp: New file. + * libjava.mauve/DejaGNUTestHarness.java: New file. + +1998-12-08 Tom Tromey + + * Various: removed all test files that migrated to Mauve. + +1998-12-07 Tom Tromey + + * libjava.lang/Array_1.java (main): Removed extraneous + getSuperclass call. + +1998-11-23 Tom Tromey + + * libjava.lang/Finalize_1.java (main): Clear `f' before GC. + +1998-10-08 Tom Tromey + + * libjava.lang/Thread_1.out: Added missing line. + +Fri Oct 2 14:55:46 1998 Tom Tromey + + * libjava.lang/Array_1.java: Changed so Cloneable test can run + even if clone test itself fails. + + * libjava.lang/Array_1.java: Uncommented calls to getSuperclass. + Added test to see if array implements Cloneable. + +Thu Oct 1 11:28:06 1998 Tom Tromey + + * libjava.lang/Array_1.java: New file. + * libjava.lang/Array_1.out: New file. + +Thu Oct 1 13:51:00 1998 Anthony Green + + * testsuite/lib/libjava.exp: Find qthreads library correctly. + +Tue Sep 29 16:36:43 1998 Warren Levy + + * libjava.util/Hashtable_1.java, libjava.util/Hashtable_1.out: Created. + +Tue Sep 29 00:40:26 1998 Tom Tromey + + * libjava.lang/Thread_1.java (started): New field. + (run): Set `started'. Handle all synchronization here. + (Thread_1): Initialize `started'. + (doit): Just start both threads and let them handle their own + synchronization. + + * libjava.lang/Boolean_5.out: Changed to reflect the + Boolean_5.java changes. + * libjava.lang/Boolean_5.java: Don't replace the system + properties, just augment them. Don't print the property object. + * libjava.lang/Long_2.out: Changed to reflect Long_2.java + changes. + * libjava.lang/Long_2.java: Don't replace the system properties, + just augment them. Don't print the property object. + * libjava.lang/Integer_2.out: Changed to reflect Integer_2.java + changes. + * libjava.lang/Integer_2.java: Don't replace the system + properties, just augment them. Don't print the property object. + +Sat Sep 26 15:57:39 1998 Tom Tromey + + * libjava.lang/Thread_1.java (main): Catch InterruptedException. + +Tue Sep 22 13:45:58 1998 Tom Tromey + + * libjava.lang/Thread_1.out: New file. + * libjava.lang/Thread_1.java: New file. + +Mon Sep 21 14:20:08 1998 Tom Tromey + + * lib/libjava.exp (test_libjava): Use runtest_file_p to see if + test should be short-circuited. + +Tue Sep 15 13:57:45 1998 Tom Tromey + + * libjava.lang/Character_9.java: New file. + * libjava.lang/Character_9.out: New file. + +Mon Sep 14 12:27:04 1998 Tom Tromey + + * libjava.lang/Character_8.out: New file. + * libjava.lang/Character_8.java: New file. + * libjava.lang/Character_7.out: New file. + * libjava.lang/Character_7.java: New file. + * libjava.lang/Character_6.out: New file. + * libjava.lang/Character_6.java: New file. + * libjava.lang/Character_5.out: New file. + * libjava.lang/Character_5.java: New file. + * libjava.lang/Character_4.out: New file. + * libjava.lang/Character_4.java: New file. + * libjava.lang/Character_3.out: New file. + * libjava.lang/Character_3.java: New file. + * libjava.lang/Character_2.out: New file. + * libjava.lang/Character_2.java: New file. + +Fri Sep 11 10:04:55 1998 Tom Tromey + + * libjava.lang/Character_1.out: New file. + * libjava.lang/Character_1.java: New file. + +Fri Sep 18 14:43:59 1998 Warren Levy + + * libjava.lang/Long_1.java, libjava.lang/Long_1.out, + libjava.lang/Long_2.java, libjava.lang/Long_2.out: Created. + +Fri Sep 18 12:43:52 1998 Warren Levy + + * libjava.lang/Integer_1.java, libjava.lang/Integer_1.out, + libjava.lang/Integer_2.java, libjava.lang/Integer_2.out: Created. + + * libjava.lang/String_2.java, libjava.lang/String_2.out: Use JDK 1.2 + values for hashCode. + +Thu Sep 10 12:44:42 1998 Warren Levy + + * libjava.lang/String_1.java, libjava.lang/String_1.out, + libjava.lang/String_2.java, libjava.lang/String_2.out, + libjava.lang/String_3.java, libjava.lang/String_3.out, + libjava.lang/String_4.java, libjava.lang/String_4.out, + libjava.lang/String_5.java, libjava.lang/String_5.out, + libjava.lang/String_6.java, libjava.lang/String_6.out, + libjava.lang/String_7.java, libjava.lang/String_7.out, + libjava.lang/String_8.java, libjava.lang/String_8.out, + libjava.lang/String_9.java, libjava.lang/String_9.out: Created. + +Tue Sep 8 13:31:59 1998 Warren Levy + + * libjava.lang/Byte_1.java, libjava.lang/Byte_1.out, + libjava.lang/Short_1.java, libjava.lang/Short_1.out: New files. + +Thu Sep 3 15:57:57 1998 Warren Levy + + * libjava.lang/Boolean_1.java, libjava.lang/Boolean_1.out, + libjava.lang/Boolean_2.java, libjava.lang/Boolean_2.out, + libjava.lang/Boolean_3.java, libjava.lang/Boolean_3.out, + libjava.lang/Boolean_4.java, libjava.lang/Boolean_4.out, + libjava.lang/Boolean_5.java, libjava.lang/Boolean_5.out: Created. + +Tue Sep 1 12:27:54 1998 Tom Tromey + + * lib/libjava.exp (bytecompile_file): Don't throw error if byte + compilation fails. Added `srcfile_in' argument. Changed return + value. + (test_libjava): Gracefully handle byte-compilation failure. + + * libjava.lang/System_15.java (main): Typo fix. + (System_15): Choose correct class name. + (X): Moved into System_15. + + * libjava.lang/System_1.java, libjava.lang/System_1.out, + libjava.lang/System_10.java, libjava.lang/System_10.out, + libjava.lang/System_11.java, libjava.lang/System_11.out, + libjava.lang/System_12.java, libjava.lang/System_12.out, + libjava.lang/System_13.java, libjava.lang/System_13.out, + libjava.lang/System_14.java, libjava.lang/System_14.out, + libjava.lang/System_15.java, libjava.lang/System_15.out, + libjava.lang/System_2.java, libjava.lang/System_2.out, + libjava.lang/System_3.java, libjava.lang/System_3.out, + libjava.lang/System_4.java, libjava.lang/System_4.out, + libjava.lang/System_5.java, libjava.lang/System_5.out, + libjava.lang/System_6.java, libjava.lang/System_6.out, + libjava.lang/System_7.java, libjava.lang/System_7.out, + libjava.lang/System_8.java, libjava.lang/System_8.out, + libjava.lang/System_9.java, libjava.lang/System_9.out: New files. + + * lib/libjava.exp (test_libjava): Only add -lgc or -lqthreads if + library is actually found. + + * lib/libjava.exp (test_libjava): Look for qthreads. + +Mon Aug 31 17:49:21 1998 Warren Levy + + * libjava.util/Random_1.java, libjava.util/Random_1.out, + libjava.util/Random_2.java, libjava.util/Random_2.out, + libjava.util/Random_3.java, libjava.util/Random_3.out, + libjava.util/Random_4.java, libjava.util/Random_4.out, + libjava.util/Random_5.java, libjava.util/Random_5.out, + libjava.util/Random_6.java, libjava.util/Random_6.out, + libjava.util/Random_7.java, libjava.util/Random_7.out, + libjava.util/Random_8.java, libjava.util/Random_8.out, + libjava.util/test.exp: Created. + +Mon Aug 31 16:37:19 1998 Tom Tromey + + * lib/libjava.exp: Changed gjavac to gcj everywhere. + +Wed Aug 26 12:20:10 1998 Anthony Green + + * Makefile.am (EXPECT,RUNTEST): Find expect and runtest + correctly. + * Makefile.in: Rebuild. + +Tue Aug 25 18:43:33 1998 Anthony Green + + * lib/libjava.exp: Fix CLASSPATH setting. + +Tue Aug 25 17:27:37 1998 Anthony Green + + * ChangeLog, lib/libjava.exp, config/default.exp, + libjava.lang/Finalize_1.java, libjava.lang/Finalize_1.out, + libjava.lang/Float_1.java, libjava.lang/Float_1.out + libjava.lang/test.exp, Makefile.am, Makefile.in: Created. + diff --git a/libjava/testsuite/Makefile.am b/libjava/testsuite/Makefile.am new file mode 100644 index 00000000000..e1d359d8f76 --- /dev/null +++ b/libjava/testsuite/Makefile.am @@ -0,0 +1,15 @@ +## Process this file with automake to produce Makefile.in. + +AUTOMAKE_OPTIONS = foreign dejagnu no-installinfo + +# Setup the testing framework, if you have one +EXPECT = `if [ -f $(top_builddir)/../expect/expect ] ; then \ + echo $(top_builddir)/../expect/expect ; \ + else echo expect ; fi` + +RUNTEST = `if [ -f $(top_srcdir)/../dejagnu/runtest ] ; then \ + echo $(top_srcdir)/../dejagnu/runtest ; \ + else echo runtest; fi` + +RUNTESTFLAGS = @AM_RUNTESTFLAGS@ + diff --git a/libjava/testsuite/Makefile.in b/libjava/testsuite/Makefile.in new file mode 100644 index 00000000000..764c148a3ca --- /dev/null +++ b/libjava/testsuite/Makefile.in @@ -0,0 +1,251 @@ +# Makefile.in generated automatically by automake 1.4 from Makefile.am + +# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + + +SHELL = @SHELL@ + +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ +prefix = @prefix@ +exec_prefix = @exec_prefix@ + +bindir = @bindir@ +sbindir = @sbindir@ +libexecdir = @libexecdir@ +datadir = @datadir@ +sysconfdir = @sysconfdir@ +sharedstatedir = @sharedstatedir@ +localstatedir = @localstatedir@ +libdir = @libdir@ +infodir = @infodir@ +mandir = @mandir@ +includedir = @includedir@ +oldincludedir = /usr/include + +DESTDIR = + +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ + +top_builddir = .. + +ACLOCAL = @ACLOCAL@ +AUTOCONF = @AUTOCONF@ +AUTOMAKE = @AUTOMAKE@ +AUTOHEADER = @AUTOHEADER@ + +INSTALL = @INSTALL@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS) +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +transform = @program_transform_name@ + +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_alias = @build_alias@ +build_triplet = @build@ +host_alias = @host_alias@ +host_triplet = @host@ +target_alias = @target_alias@ +target_triplet = @target@ +AM_RUNTESTFLAGS = @AM_RUNTESTFLAGS@ +AR = @AR@ +AS = @AS@ +CC = @CC@ +COMPPATH = @COMPPATH@ +CPP = @CPP@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +EH_COMMON_INCLUDE = @EH_COMMON_INCLUDE@ +EXEEXT = @EXEEXT@ +GCDEPS = @GCDEPS@ +GCINCS = @GCINCS@ +GCLIBS = @GCLIBS@ +GCOBJS = @GCOBJS@ +LIBGCJ_CFLAGS = @LIBGCJ_CFLAGS@ +LIBGCJ_CXXFLAGS = @LIBGCJ_CXXFLAGS@ +LIBGCJ_JAVAFLAGS = @LIBGCJ_JAVAFLAGS@ +MAINT = @MAINT@ +MAKEINFO = @MAKEINFO@ +PACKAGE = @PACKAGE@ +PERL = @PERL@ +RANLIB = @RANLIB@ +THREADDEPS = @THREADDEPS@ +THREADINCS = @THREADINCS@ +THREADLIBS = @THREADLIBS@ +THREADOBJS = @THREADOBJS@ +VERSION = @VERSION@ +here = @here@ +libgcj_basedir = @libgcj_basedir@ + +AUTOMAKE_OPTIONS = foreign dejagnu no-installinfo + +# Setup the testing framework, if you have one +EXPECT = `if [ -f $(top_builddir)/../expect/expect ] ; then \ + echo $(top_builddir)/../expect/expect ; \ + else echo expect ; fi` + + +RUNTEST = `if [ -f $(top_srcdir)/../dejagnu/runtest ] ; then \ + echo $(top_srcdir)/../dejagnu/runtest ; \ + else echo runtest; fi` + + +RUNTESTFLAGS = @AM_RUNTESTFLAGS@ +mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs +CONFIG_HEADER = ../include/config.h +CONFIG_CLEAN_FILES = +DIST_COMMON = ChangeLog Makefile.am Makefile.in + + +DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) + +TAR = tar +GZIP_ENV = --best +all: all-redirect +.SUFFIXES: +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) + cd $(top_srcdir) && $(AUTOMAKE) --foreign testsuite/Makefile + +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES) + cd $(top_builddir) \ + && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status + +tags: TAGS +TAGS: + + +distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir) + +subdir = testsuite + +distdir: $(DISTFILES) + here=`cd $(top_builddir) && pwd`; \ + top_distdir=`cd $(top_distdir) && pwd`; \ + distdir=`cd $(distdir) && pwd`; \ + cd $(top_srcdir) \ + && $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --foreign testsuite/Makefile + @for file in $(DISTFILES); do \ + d=$(srcdir); \ + if test -d $$d/$$file; then \ + cp -pr $$/$$file $(distdir)/$$file; \ + else \ + test -f $(distdir)/$$file \ + || ln $$d/$$file $(distdir)/$$file 2> /dev/null \ + || cp -p $$d/$$file $(distdir)/$$file || :; \ + fi; \ + done + +DEJATOOL = $(PACKAGE) + +RUNTESTDEFAULTFLAGS = --tool $(DEJATOOL) --srcdir $$srcdir + +check-DEJAGNU: site.exp + srcdir=`cd $(srcdir) && pwd`; export srcdir; \ + EXPECT=$(EXPECT); export EXPECT; \ + runtest=$(RUNTEST); \ + if $(SHELL) -c "$$runtest --version" > /dev/null 2>&1; then \ + $$runtest $(RUNTESTDEFAULTFLAGS) $(RUNTESTFLAGS); \ + else echo "WARNING: could not find \`runtest'" 1>&2; :;\ + fi +site.exp: Makefile + @echo 'Making a new site.exp file...' + @test ! -f site.bak || rm -f site.bak + @echo '## these variables are automatically generated by make ##' > $@-t + @echo '# Do not edit here. If you wish to override these values' >> $@-t + @echo '# edit the last section' >> $@-t + @echo 'set tool $(DEJATOOL)' >> $@-t + @echo 'set srcdir $(srcdir)' >> $@-t + @echo 'set objdir' `pwd` >> $@-t + @echo 'set host_alias $(host_alias)' >> $@-t + @echo 'set host_triplet $(host_triplet)' >> $@-t + @echo 'set target_alias $(target_alias)' >> $@-t + @echo 'set target_triplet $(target_triplet)' >> $@-t + @echo 'set build_alias $(build_alias)' >> $@-t + @echo 'set build_triplet $(build_triplet)' >> $@-t + @echo '## All variables above are generated by configure. Do Not Edit ##' >> $@-t + @test ! -f site.exp || sed '1,/^## All variables above are.*##/ d' site.exp >> $@-t + @test ! -f site.exp || mv site.exp site.bak + @mv $@-t site.exp +info-am: +info: info-am +dvi-am: +dvi: dvi-am +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) check-DEJAGNU +check: check-am +installcheck-am: +installcheck: installcheck-am +install-info-am: +install-info: install-info-am +install-exec-am: +install-exec: install-exec-am + +install-data-am: +install-data: install-data-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am +install: install-am +uninstall-am: +uninstall: uninstall-am +all-am: Makefile +all-redirect: all-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install +installdirs: + + +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -rm -f Makefile $(CONFIG_CLEAN_FILES) + -rm -f config.cache config.log stamp-h stamp-h[0-9]* + +maintainer-clean-generic: +mostlyclean-am: mostlyclean-generic + +mostlyclean: mostlyclean-am + +clean-am: clean-generic mostlyclean-am + +clean: clean-am + +distclean-am: distclean-generic clean-am + +distclean: distclean-am + +maintainer-clean-am: maintainer-clean-generic distclean-am + @echo "This command is intended for maintainers to use;" + @echo "it deletes files that may require special tools to rebuild." + +maintainer-clean: maintainer-clean-am + +.PHONY: tags distdir check-DEJAGNU info-am info dvi-am dvi check \ +check-am installcheck-am installcheck install-info-am install-info \ +install-exec-am install-exec install-data-am install-data install-am \ +install uninstall-am uninstall all-redirect all-am all installdirs \ +mostlyclean-generic distclean-generic clean-generic \ +maintainer-clean-generic clean mostlyclean distclean maintainer-clean + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/libjava/testsuite/config/default.exp b/libjava/testsuite/config/default.exp new file mode 100644 index 00000000000..90967cccc18 --- /dev/null +++ b/libjava/testsuite/config/default.exp @@ -0,0 +1 @@ +load_lib "standard.exp" diff --git a/libjava/testsuite/lib/libjava.exp b/libjava/testsuite/lib/libjava.exp new file mode 100644 index 00000000000..9c8b36d19a9 --- /dev/null +++ b/libjava/testsuite/lib/libjava.exp @@ -0,0 +1,450 @@ +# Copyright (C) 1998, 1999 Cygnus Solutions + +load_lib "libgloss.exp" + +# GCJ_UNDER_TEST is the compiler under test. + +global tmpdir + +if ![info exists tmpdir] { + set tmpdir "/tmp" +} + +# Find `jv-scan'. FIXME: this relies on DejaGnu internals. These +# should probably be exposed in a better way. +proc find_jvscan {} { + global tool_root_dir + + set file [lookfor_file $tool_root_dir jv-scan] + if { $file == "" } { + set file [lookfor_file $tool_root_dir gcc/jv-scan]; + } + if {$file == ""} { + set file jv-scan + } + return $file +} + +proc bytecompile_file { file objdir {classpath {}} } { + global env + set dirname [file dirname $file]; + + catch {unset env(CLASSPATH)} + if {$classpath != ""} then { + set env(CLASSPATH) $classpath + } + if {[catch {system "cd $dirname; javac $file -d $objdir"} msg]} then { + verbose "couldn't compile $file: $msg" + set r 0 + } else { + set r 1 + } + return $r +} + +set libjava_initialized 0 + +# +# Build the status wrapper library as needed. +# +proc libjava_init { args } { + global wrapper_file; + global wrap_compile_flags; + global libjava_initialized + global GCJ_UNDER_TEST + global TOOL_EXECUTABLE + + if { $libjava_initialized == 1 } { return; } + + if ![info exists GCJ_UNDER_TEST] { + if [info exists TOOL_EXECUTABLE] { + set GCJ_UNDER_TEST $TOOL_EXECUTABLE; + } else { + set GCJ_UNDER_TEST "[find_gcj]" + } + } + + set wrapper_file ""; + set wrap_compile_flags ""; + if [target_info exists needs_status_wrapper] { + set result [build_wrapper "testglue.o"]; + if { $result != "" } { + set wrapper_file [lindex $result 0]; + set wrap_compile_flags [lindex $result 1]; + } else { + warning "Status wrapper failed to build." + } + } + + set libjava_initialized 1 +} + +# Compute arguments needed for compiler. +proc libjava_arguments {} { + global base_dir + global LIBJAVA + global LIBGC + global srcdir subdir objdir + global TOOL_OPTIONS + global GCJ_UNDER_TEST + global tmpdir + global runtests + + if [info exists LIBJAVA] { + set libjava $LIBJAVA; + } else { + set gp [get_multilibs]; + if { $gp != "" } { + if [file exists "$gp/libjava/libgcj.a"] { + set libjava "-L$gp/libjava -lgcj"; + } + } + if ![info exists libjava] { + set libjava [findfile $base_dir/../../libjava/libgcj.a "-L$base_dir/../../libjava -lgcj" -lgcj] + } + } + + if [info exists LIBGC] { + set libgc $LIBGC; + } else { + set gp [get_multilibs]; + if { $gp != "" } { + if [file exists "$gp/boehm-gc/libgcjgc.a"] { + set libgc "-L$gp/boehm-gc -lgcjgc"; + } + } + if ![info exists libgc] { + set libgc [findfile $base_dir/../../boehm-gc/libgcjgc.a \ + "-L$base_dir/../../boehm-gc -lgcjgc" \ + {}] + } + } + + if [info exists LIBQTHREADS] { + set libqthreads $LIBQTHREADS + } else { + set gp [get_multilibs] + if { $gp != "" } { + if [file exists "$gp/qthreads/libgcjcoop.a"] { + set libqthreads "-L$gp/qthreads -lgcjcoop"; + } + } + if ![info exists libqthreads] { + set libqthreads [findfile $base_dir/../../qthreads/libgcjcoop.a \ + "-L$base_dir/../../qthreads -lgcjcoop" \ + {}] + } + } + + # FIXME: there's no way to determine whether -lpthread is + # required. We should get this info from configure, or it should + # just be in the compiler driver. + + verbose "using LIBJAVA = $libjava" 2 + verbose "using LIBGC = $libgc" 2 + verbose "using LIBQTHREADS = $libqthreads" 2 + set args "" + + # Basically we want to build up a colon separated path list from + # the value of $libjava. + + # First strip away any -L arguments. + regsub -all -- "-L" $libjava "" ld_library_path + + # Then remove any -lgcj argument. + regsub -all -- " -lgcj.*" $ld_library_path "" ld_library_path + + # First strip away any -L arguments. + regsub -all -- "-L" $libgc $ld_library_path ld_library_path + + # Then remove any -lgcjgc argument. + regsub -all -- " -lgcjgc.*" $ld_library_path "" ld_library_path + + # That's enough to make things work for the normal case. + # If we wanted to handle an arbitrary value of libjava, + # then we'd have to do a lot more work. + + # Set variables the dynamic linker looks at. + setenv LD_LIBRARY_PATH $ld_library_path + setenv SHLIB_PATH $ld_library_path + + # Set the CLASSPATH environment variable + verbose "CLASSPATH is $objdir/.." + global env + set env(CLASSPATH) "$objdir/.." + + global wrapper_file wrap_compile_flags; + lappend args "additional_flags=$wrap_compile_flags"; + lappend args "libs=$wrapper_file"; + lappend args "libs=$libjava"; + lappend args "libs=$libgc"; + lappend args "libs=$libqthreads" + lappend args debug + + if { [target_info needs_status_wrapper]!="" && [info exists gluefile] } { + lappend args "libs=${gluefile}" + lappend args "ldflags=$wrap_flags" + } + + if [info exists TOOL_OPTIONS] { + lappend args "additional_flags=$TOOL_OPTIONS" + } + lappend args "compiler=$GCJ_UNDER_TEST" + + return $args +} + + +# +# Run the test specified by srcfile and resultfile. compile_args and +# exec_args are additional arguments to be passed in when compiling and +# running the testcase, respectively. +# +proc test_libjava_from_source { options srcfile compile_args inpfile resultfile exec_args } { + global base_dir + global LIBJAVA + global LIBGC + global srcdir subdir objdir + global TOOL_OPTIONS + global GCJ_UNDER_TEST + global tmpdir + global runtests + + set errname [file rootname [file tail $srcfile]] + if {! [runtest_file_p $runtests $errname]} { + return + } + + set args [libjava_arguments] + # Add the --main flag + lappend args "additional_flags=--main=[file rootname [file tail $srcfile]]" + if { $compile_args != "" } { + lappend args "additional_flags=$compile_args" + } + + regsub "^.*/(\[^/.\]+)\[.\]\[^/]*$" "$srcfile" "\\1" out + set executable "${objdir}/$out" + if { $compile_args != "" } { + set errname "$errname $compile_args" + } + + if { [target_compile $srcfile "$executable" executable $args] != "" } { + fail "$errname compilation from source" + setup_xfail "*-*-*" + fail "$errname execution from source compiled test" + setup_xfail "*-*-*" + fail "$errname output from source compiled test" + return; + } + pass "$errname compilation from source" + + if { $exec_args == "no-exec" } { + return + } + + set result [libjava_load $executable "$exec_args" "$inpfile"]; + set status [lindex $result 0]; + set output [lindex $result 1]; + $status "$errname execution from source compiled test" + if { $status != "pass" } { + setup_xfail "*-*-*" + fail "$errname output from source compiled test" + return; + } + + verbose "resultfile is $resultfile" + set id [open $resultfile r]; + set expected "" + append expected [read $id]; + regsub -all "\r" "$output" "" output; + regsub "\n*$" $expected "" expected + regsub "\n*$" $output "" output + regsub "^\n*" $expected "" expected + regsub "^\n*" $output "" output + regsub -all "\[ \t\]\[ \t\]*" $expected " " expected + regsub -all "\[ \t\]*\n\n*" $expected "\n" expected + regsub -all "\[ \t\]\[ \t\]*" $output " " output + regsub -all "\[ \t\]*\n\n*" $output "\n" output + verbose "expected is $expected" + verbose "actual is $output" + set passed 0; + if {$options == "regexp_match"} { + if [regexp $expected $output] { + set passed 1; + } + } else { + if { $expected == $output } { + set passed 1; + } + } + if { $passed == 1 } { + pass "$errname output from source compiled test" + } else { + clone_output "expected was $expected" + clone_output "output was $output" + fail "$errname output from source compiled test" + } + close $id; +} + +# +# Run the test specified by srcfile and resultfile. compile_args and +# exec_args are additional arguments to be passed in when compiling and +# running the testcase, respectively. +# +proc test_libjava_from_javac { options srcfile compile_args inpfile resultfile exec_args } { + global base_dir + global LIBJAVA + global LIBGC + global srcdir subdir objdir + global TOOL_OPTIONS + global GCJ_UNDER_TEST + global tmpdir + global runtests + + set errname [file rootname [file tail $srcfile]] + if {! [runtest_file_p $runtests $errname]} { + return + } + + # bytecompile files with Sun's compiler for now. + set bc_ok [bytecompile_file $srcfile $objdir] + if {! $bc_ok} then { + fail "$errname byte compilation" + setup_xfail "*-*-*" + fail "$errname compilation from bytecode" + setup_xfail "*-*-*" + fail "$errname execution from bytecode->native test" + setup_xfail "*-*-*" + fail "$errname output from bytecode->native test" + return + } + pass "$errname byte compilation" + + # Find name to use for --main, and name of all class files. + set jvscan [find_jvscan] + verbose "jvscan is $jvscan" + set main_name [string trim \ + [target_compile $srcfile "" none \ + "compiler=$jvscan additional_flags=--print-main"]] + verbose "main name is $main_name" + set class_out [string trim \ + [target_compile $srcfile "" none \ + "compiler=$jvscan additional_flags=--list-class"]] + verbose "class list is $class_out" + # FIXME: As of Wed Feb 24 1999, `jv-scan --list-class' prints + # nothing if the file contains an interface and not a class. I + # believe this is a jv-scan bug. + if {$class_out == ""} then { + set class_files [file rootname [file tail $srcfile]].class + } else { + # Turn "a b" into "a.class b.class". + set class_files [join [split [string trim $class_out]] ".class "].class + } + + # Initial arguments. + set args [libjava_arguments] + + # Usually it is an error for a test program not to have a `main' + # method. However, for no-exec tests it is ok. + if {$main_name == ""} { + if {$exec_args != "no-exec"} { + perror "No `main' given in program $errname" + return + } else { + set type object + set executable [file rootname [file tail $srcfile]].o + } + } else { + set type executable + lappend args "additional_flags=--main=$main_name" + set executable "${objdir}/$main_name" + } + + if { $compile_args != "" } { + lappend args "additional_flags=$compile_args" + } + + if { $compile_args != "" } { + set errname "$errname $compile_args" + } + + if { [target_compile $class_files "$executable" $type $args] != "" } { + fail "$errname compilation from bytecode" + setup_xfail "*-*-*" + if {$exec_args != "no-exec"} { + fail "$errname execution from bytecode->native test" + setup_xfail "*-*-*" + fail "$errname output from bytecode->native test" + } + return; + } + pass "$errname compilation from bytecode" + + if { $exec_args == "no-exec" } { + return + } + + set result [libjava_load $executable "$exec_args" "$inpfile"]; + set status [lindex $result 0]; + set output [lindex $result 1]; + $status "$errname execution from bytecode->native test" + if { $status != "pass" } { + setup_xfail "*-*-*" + fail "$errname output from bytecode->native test" + return; + } + + verbose "resultfile is $resultfile" + set id [open $resultfile r]; + set expected "" + append expected [read $id]; + regsub -all "\r" "$output" "" output; + regsub "\n*$" $expected "" expected + regsub "\n*$" $output "" output + regsub "^\n*" $expected "" expected + regsub "^\n*" $output "" output + regsub -all "\[ \t\]\[ \t\]*" $expected " " expected + regsub -all "\[ \t\]*\n\n*" $expected "\n" expected + regsub -all "\[ \t\]\[ \t\]*" $output " " output + regsub -all "\[ \t\]*\n\n*" $output "\n" output + verbose "expected is $expected" + verbose "actual is $output" + set passed 0; + if {$options == "regexp_match"} { + if [regexp $expected $output] { + set passed 1; + } + } else { + if { $expected == $output } { + set passed 1; + } + } + if { $passed == 1 } { + pass "$errname output from bytecode->native test" + } else { + clone_output "expected was $expected" + clone_output "output was $output" + fail "$errname output from bytecode->native test" + } + close $id; +} + +# +# Run the test specified by srcfile and resultfile. compile_args and +# exec_args are additional arguments to be passed in when compiling and +# running the testcase, respectively. +# +proc test_libjava { options srcfile compile_args inpfile resultfile exec_args } { + test_libjava_from_source $options $srcfile $compile_args $inpfile $resultfile $exec_args + test_libjava_from_javac $options $srcfile $compile_args $inpfile $resultfile $exec_args + } + +# +# libjava_version -- extract and print the version number of libjavap +# +proc default_libjava_version {} { +} + +proc default_libjava_start { } { +} diff --git a/libjava/testsuite/libjava.compile/Case.java b/libjava/testsuite/libjava.compile/Case.java new file mode 100644 index 00000000000..c5eb1d51947 --- /dev/null +++ b/libjava/testsuite/libjava.compile/Case.java @@ -0,0 +1,15 @@ +// Simple compiler test. + +public class Case +{ + public static int foo (int i, support.Case x) + { + switch (i) + { + case x.A: + return 1; + default: + return 0; + } + } +} diff --git a/libjava/testsuite/libjava.compile/Semi.java b/libjava/testsuite/libjava.compile/Semi.java new file mode 100644 index 00000000000..39b3edc84b8 --- /dev/null +++ b/libjava/testsuite/libjava.compile/Semi.java @@ -0,0 +1,8 @@ +// Simple compiler test. + +public class Semi +{ + Semi () { }; +} + + diff --git a/libjava/testsuite/libjava.compile/Statics.java b/libjava/testsuite/libjava.compile/Statics.java new file mode 100644 index 00000000000..b86a57c409e --- /dev/null +++ b/libjava/testsuite/libjava.compile/Statics.java @@ -0,0 +1,7 @@ +// Simple compiler test. + +public interface Statics { + + public static final int OwnerGrabButtonMask = 1<<24; + +} diff --git a/libjava/testsuite/libjava.compile/Twice.java b/libjava/testsuite/libjava.compile/Twice.java new file mode 100644 index 00000000000..d80760f4dd5 --- /dev/null +++ b/libjava/testsuite/libjava.compile/Twice.java @@ -0,0 +1,14 @@ +// Simple compiler test. + +public class Twice +{ + Twice (boolean q) + { + if (q) + for (int p = 0; p < 10; p++); + else + for (int p = 0; p < 10; p++); + } +} + + diff --git a/libjava/testsuite/libjava.compile/Where.java b/libjava/testsuite/libjava.compile/Where.java new file mode 100644 index 00000000000..08fcc78b1d6 --- /dev/null +++ b/libjava/testsuite/libjava.compile/Where.java @@ -0,0 +1,12 @@ +// Simple compiler test. + +public final class Where implements support.Waldo +{ + int WhereIsWaldo () + { + // The compiler should find 'here' in support.Waldo. + return here; + } +} + + diff --git a/libjava/testsuite/libjava.compile/euc_comment1.java b/libjava/testsuite/libjava.compile/euc_comment1.java new file mode 100644 index 00000000000..bb556236eac --- /dev/null +++ b/libjava/testsuite/libjava.compile/euc_comment1.java @@ -0,0 +1,5 @@ +public class euc_comment1 { + public static void main(String[] args) { + /* ÆþÎÏ */ + } +} diff --git a/libjava/testsuite/libjava.compile/euc_comment2.java b/libjava/testsuite/libjava.compile/euc_comment2.java new file mode 100644 index 00000000000..9a9426f8005 --- /dev/null +++ b/libjava/testsuite/libjava.compile/euc_comment2.java @@ -0,0 +1,5 @@ +public class euc_comment2 { + public static void main(String[] args) { + // ÆþÎÏ + } +} diff --git a/libjava/testsuite/libjava.compile/euc_comment3.java b/libjava/testsuite/libjava.compile/euc_comment3.java new file mode 100644 index 00000000000..b0f35d09d34 --- /dev/null +++ b/libjava/testsuite/libjava.compile/euc_comment3.java @@ -0,0 +1,5 @@ +public class euc_comment3 { + public static void main(String[] args) { + // ÆþÎÏ + } +} diff --git a/libjava/testsuite/libjava.compile/perc.java b/libjava/testsuite/libjava.compile/perc.java new file mode 100644 index 00000000000..8dc2f6f01fb --- /dev/null +++ b/libjava/testsuite/libjava.compile/perc.java @@ -0,0 +1,9 @@ +// This generates code that `gcj -C' doesn't like. + +public class perc +{ + public static void main (String[] args) + { + System.out.println (27.0 % 10.0); + } +} diff --git a/libjava/testsuite/libjava.compile/sjis_comment1.java b/libjava/testsuite/libjava.compile/sjis_comment1.java new file mode 100644 index 00000000000..26132821960 --- /dev/null +++ b/libjava/testsuite/libjava.compile/sjis_comment1.java @@ -0,0 +1,5 @@ +public class sjis_comment1 { + public static void main(String[] args) { + /* “ü—Í */ + } +} diff --git a/libjava/testsuite/libjava.compile/sjis_comment2.java b/libjava/testsuite/libjava.compile/sjis_comment2.java new file mode 100644 index 00000000000..d4ae92f191b --- /dev/null +++ b/libjava/testsuite/libjava.compile/sjis_comment2.java @@ -0,0 +1,5 @@ +public class sjis_comment2 { + public static void main(String[] args) { + // “ü—Í + } +} diff --git a/libjava/testsuite/libjava.compile/sjis_comment3.java b/libjava/testsuite/libjava.compile/sjis_comment3.java new file mode 100644 index 00000000000..7370c4e444d --- /dev/null +++ b/libjava/testsuite/libjava.compile/sjis_comment3.java @@ -0,0 +1,5 @@ +public class sjis_comment3 { + public static void main(String[] args) { + // “ü—Í + } +} diff --git a/libjava/testsuite/libjava.compile/support/Case.java b/libjava/testsuite/libjava.compile/support/Case.java new file mode 100644 index 00000000000..709b47aca5a --- /dev/null +++ b/libjava/testsuite/libjava.compile/support/Case.java @@ -0,0 +1,6 @@ +package support; + +public class Case +{ + public static final int A = 9; +} diff --git a/libjava/testsuite/libjava.compile/support/Waldo.java b/libjava/testsuite/libjava.compile/support/Waldo.java new file mode 100644 index 00000000000..e28829d7af5 --- /dev/null +++ b/libjava/testsuite/libjava.compile/support/Waldo.java @@ -0,0 +1,7 @@ +package support; + +public interface Waldo { + + public static final int here = 9; + +} diff --git a/libjava/testsuite/libjava.compile/test.exp b/libjava/testsuite/libjava.compile/test.exp new file mode 100644 index 00000000000..db6aef19bb3 --- /dev/null +++ b/libjava/testsuite/libjava.compile/test.exp @@ -0,0 +1,10 @@ +global srcdir subdir + +catch "glob -nocomplain ${srcdir}/${subdir}/*.java" srcfiles +verbose "srcfiles are $srcfiles" + +set prefix "" +foreach x $srcfiles { + test_libjava $options "$x" "" "" "" "no-exec" + test_libjava $options "$x" "-O" "" "" "no-exec" +} diff --git a/libjava/testsuite/libjava.lang/Array_1.java b/libjava/testsuite/libjava.lang/Array_1.java new file mode 100644 index 00000000000..1fcf04eeb4d --- /dev/null +++ b/libjava/testsuite/libjava.lang/Array_1.java @@ -0,0 +1,18 @@ +// Test of array stuff. Technically this probably isn't in java.lang. + +public class Array_1 +{ + public static void main (String[] args) + { + int x[][] = { { 1, 2}, null }; + + System.out.println(Cloneable.class.isInstance(x)); + + // This example is from the Java Spec book. + int y[][] = (int[][]) x.clone(); + System.out.println(x == y); + System.out.println(x[0] == y[0] && x[1] == y[1]); + + System.out.println(x.getClass().getSuperclass()); + } +} diff --git a/libjava/testsuite/libjava.lang/Array_1.out b/libjava/testsuite/libjava.lang/Array_1.out new file mode 100644 index 00000000000..3cc754d2ef9 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Array_1.out @@ -0,0 +1,4 @@ +true +false +true +class java.lang.Object diff --git a/libjava/testsuite/libjava.lang/Finalize_1.java b/libjava/testsuite/libjava.lang/Finalize_1.java new file mode 100644 index 00000000000..b1a4d9575f2 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Finalize_1.java @@ -0,0 +1,28 @@ +// Finalize.java - Test code for finalizers. + +import java.io.*; +import java.util.*; +import java.lang.Runtime; + +public final class Finalize_1 +{ + public static void main (String[] args) + { + Finalize_1 f; + Runtime t; + + t = Runtime.getRuntime (); + + for (int i = 0; i < 3; ++i) + f = new Finalize_1 (); + f = null; + + t.gc (); + t.runFinalization (); + } + + public void finalize () throws Throwable + { + System.out.print ("Finalize "); + } +} diff --git a/libjava/testsuite/libjava.lang/Finalize_1.out b/libjava/testsuite/libjava.lang/Finalize_1.out new file mode 100644 index 00000000000..45b1f96bfa0 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Finalize_1.out @@ -0,0 +1 @@ +Finalize Finalize Finalize diff --git a/libjava/testsuite/libjava.lang/Float_1.java b/libjava/testsuite/libjava.lang/Float_1.java new file mode 100644 index 00000000000..cb147ee8aca --- /dev/null +++ b/libjava/testsuite/libjava.lang/Float_1.java @@ -0,0 +1,52 @@ +/* + +Date: 25 Aug 1998 16:04:00 -0000 +From: Andrew Haley +To: java-project@cygnus.com +Subject: Help: vtable problem? + +My little program: + +----------------------------------------------------------------------- +import java.lang.*; + + public class widget + { + public static void main (String argv[]) + { + int test = Float.floatToIntBits((float)2.0); + String s = Integer.toHexString(test); + + System.out.print (s+"\n"); + } + + } +----------------------------------------------------------------------- +prints out + +40000000 + +with Sun's interpreter, but prints out + +true + +when compiled with gcj; PrintStream dispatches a string arg as a +boolean rather than as a String. I've tried to rebuild everything. + +? + +Thanks, +Andrew. + +*/ + +public class Float_1 +{ + public static void main (String argv[]) + { + int test = Float.floatToIntBits((float)2.0); + String s = Integer.toHexString(test); + + System.out.print (s+"\n"); + } +} diff --git a/libjava/testsuite/libjava.lang/Float_1.out b/libjava/testsuite/libjava.lang/Float_1.out new file mode 100644 index 00000000000..52f3f6a7451 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Float_1.out @@ -0,0 +1 @@ +40000000 diff --git a/libjava/testsuite/libjava.lang/Invoke_1.java b/libjava/testsuite/libjava.lang/Invoke_1.java new file mode 100644 index 00000000000..bc4678301ce --- /dev/null +++ b/libjava/testsuite/libjava.lang/Invoke_1.java @@ -0,0 +1,27 @@ +// Test of failing method invocation. + +public class Invoke_1 +{ + public void call_me () + { + System.out.println ("no"); + } + + public static Invoke_1 get_i () + { + return null; + } + + public static void main (String[] args) + { + Invoke_1 i = get_i (); + try + { + i.call_me (); + } + catch (NullPointerException ok) + { + System.out.println ("ok"); + } + } +} diff --git a/libjava/testsuite/libjava.lang/Invoke_1.out b/libjava/testsuite/libjava.lang/Invoke_1.out new file mode 100644 index 00000000000..9766475a418 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Invoke_1.out @@ -0,0 +1 @@ +ok diff --git a/libjava/testsuite/libjava.lang/Synch.java b/libjava/testsuite/libjava.lang/Synch.java new file mode 100644 index 00000000000..15e2d26b4a5 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Synch.java @@ -0,0 +1,17 @@ +public class Synch +{ + public synchronized void s() + { + // This call to notify() isn't supposed to cause a + // java.lang.IllegalMonitorStateException. + notify (); + } + + public static void main (String[] args) + { + (new Synch()).s(); + System.out.println ("Ok"); + } +} + + diff --git a/libjava/testsuite/libjava.lang/Synch.out b/libjava/testsuite/libjava.lang/Synch.out new file mode 100644 index 00000000000..7326d960397 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Synch.out @@ -0,0 +1 @@ +Ok diff --git a/libjava/testsuite/libjava.lang/Thread_1.java b/libjava/testsuite/libjava.lang/Thread_1.java new file mode 100644 index 00000000000..932afa5dd73 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Thread_1.java @@ -0,0 +1,182 @@ +// Various thread tests. + +public class Thread_1 extends Thread +{ + // The group for the workers. + static ThreadGroup subgroup; + + // Which piece of test code to try. + static int test_case; + + // Names of the tests. + static final int JOIN_GOOD = 0; + static final int JOIN_TIMEOUT = 1; + static final int JOIN_INTERRUPTED = 2; + static final int THREAD_EXIT = 3; + + // True if this is normal; false if daemon. + boolean normal; + // The other thread in the test. + Thread_1 other; + // True when the thread has entered run(). + boolean started; + + public void run () + { + try + { + if (normal) + { + System.out.println ("test " + test_case); + // Tell the main thread to start the daemon thread. + synchronized (this) + { + started = true; + notify (); + } + // Now wait for daemon to start. + synchronized (other) + { + while (! other.started) + other.wait (); + } + switch (test_case) + { + case JOIN_GOOD: + other.join (); + System.out.println ("joined"); + break; + case JOIN_TIMEOUT: + other.join (10); + System.out.println (other.isAlive()); + other.join (); + break; + case JOIN_INTERRUPTED: + other.join (); + System.out.println ("joined"); + break; + case THREAD_EXIT: + // Nothing. + break; + + default: + System.out.println ("failure"); + break; + } + } + else + { + // Let the normal thread start first. + synchronized (other) + { + while (! other.started) + other.wait(); + } + // Tell normal thread that we've started. + synchronized (this) + { + started = true; + notify (); + } + switch (test_case) + { + case JOIN_GOOD: + System.out.println ("daemon done"); + break; + case JOIN_TIMEOUT: + sleep (50); + break; + case JOIN_INTERRUPTED: + other.interrupt (); + break; + case THREAD_EXIT: + // Wait for a while. However, don't wait indefinitely + // -- we want this thread to terminate so that the + // process won't hang if there is a bug. + sleep (10000); + System.out.println ("daemon still alive"); + break; + + default: + System.out.println ("failure"); + break; + } + } + } + catch (InterruptedException e) + { + System.out.println ("interrupted"); + } + } + + public void setOther (Thread_1 x) + { + other = x; + } + + Thread_1 (String name, boolean x) + { + super (subgroup, name); + normal = x; + started = false; + setDaemon (! normal); + } + + // Run a single test. + static Thread_1 doit (int what) + { + // FIXME: we used to just use the same threads each time. That + // didn't work -- must debug. + Thread_1 dt = new Thread_1 ("daemon", false); + Thread_1 nt = new Thread_1 ("normal", true); + + dt.setOther(nt); + nt.setOther(dt); + + test_case = what; + try + { + nt.start(); + dt.start(); + + // Don't wait for the threads if we're doing the exit test. + if (what != THREAD_EXIT) + { + nt.join (); + dt.join (); + } + } + catch (InterruptedException e) + { + System.out.println ("caught bad exception"); + } + + return dt; + } + + public static void main (String[] args) + { + subgroup = new ThreadGroup ("sub"); + + doit (JOIN_GOOD); + + System.out.println ("active count = " + subgroup.activeCount ()); + + Thread_1 dt = doit (JOIN_TIMEOUT); + // Make sure that joining a dead thread works. + System.out.println ("still alive: " + dt.isAlive ()); + try + { + dt.join (); + } + catch (InterruptedException e) + { + System.out.println ("exception caught"); + } + + doit (JOIN_INTERRUPTED); + + // This test must come last. + doit (THREAD_EXIT); + } +} diff --git a/libjava/testsuite/libjava.lang/Thread_1.out b/libjava/testsuite/libjava.lang/Thread_1.out new file mode 100644 index 00000000000..1bd7a0124d9 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Thread_1.out @@ -0,0 +1,10 @@ +test 0 +daemon done +joined +active count = 2 +test 1 +true +still alive: false +test 2 +interrupted +test 3 diff --git a/libjava/testsuite/libjava.lang/Throw_1.java b/libjava/testsuite/libjava.lang/Throw_1.java new file mode 100644 index 00000000000..4a0780aec06 --- /dev/null +++ b/libjava/testsuite/libjava.lang/Throw_1.java @@ -0,0 +1,25 @@ +// Some tests of `throw'. + +public class Throw_1 +{ + public static Throwable get () + { + return null; + } + + public static void main (String[] args) + { + Throwable t = get (); + try + { + throw t; + } + catch (NullPointerException y) + { + } + catch (Throwable x) + { + System.out.println ("no"); + } + } +} diff --git a/libjava/testsuite/libjava.lang/Throw_1.out b/libjava/testsuite/libjava.lang/Throw_1.out new file mode 100644 index 00000000000..e69de29bb2d diff --git a/libjava/testsuite/libjava.lang/test.exp b/libjava/testsuite/libjava.lang/test.exp new file mode 100644 index 00000000000..cfe9cf5069c --- /dev/null +++ b/libjava/testsuite/libjava.lang/test.exp @@ -0,0 +1,34 @@ +global srcdir subdir + +catch "glob -nocomplain ${srcdir}/${subdir}/*.out" srcfiles +verbose "srcfiles are $srcfiles" + +set prefix "" +foreach x $srcfiles { + regsub "\\.out$" $x "" prefix + set bname [file tail $prefix] + set args "" + if [file exists $srcdir/$subdir/${bname}.arg] { + set id [open "$srcdir/$subdir/${bname}.arg" r]; + set args [read -nonewline $id]; + close $id; + } + if [file exists $srcdir/$subdir/${bname}.xpo] { + set resfile "$srcdir/$subdir/${bname}.xpo" + set options "regexp_match" + } else { + set resfile "${prefix}.out" + set options "" + } + + if [file exists ${prefix}.inp] { + set inpfile ${prefix}.inp + } else { + set inpfile "" + } + + verbose "inpfile is $inpfile" + + test_libjava $options "${prefix}.java" "" $inpfile $resfile $args + test_libjava $options "${prefix}.java" "-O" $inpfile $resfile $args +} diff --git a/libjava/testsuite/libjava.mauve/DejaGNUTestHarness.java b/libjava/testsuite/libjava.mauve/DejaGNUTestHarness.java new file mode 100644 index 00000000000..5c1cf5ec7c9 --- /dev/null +++ b/libjava/testsuite/libjava.mauve/DejaGNUTestHarness.java @@ -0,0 +1,31 @@ +// Copyright (c) 1998, 1999 Cygnus Solutions + +// Written by Tom Tromey + +import gnu.testlet.*; + +public class DejaGNUTestHarness extends SimpleTestHarness +{ + static String dejasrcdir; + + public String getSourceDirectory () + { + return dejasrcdir; + } + + private DejaGNUTestHarness () + { + super (/* verbose */ true, /* debug */ false); + } + + public static void main (String[] args) + { + dejasrcdir = args.length > 0 ? args[0] : ""; + DejaGNUTestHarness harness = new DejaGNUTestHarness (); + // This might seem weird, given that we check args.length above. + // However, in some cases the expect code rewrites this runtest + // invocation to have an explicit name for the test to run. + harness.runtest (args[1]); + System.exit(harness.done()); + } +} diff --git a/libjava/testsuite/libjava.mauve/mauve.exp b/libjava/testsuite/libjava.mauve/mauve.exp new file mode 100644 index 00000000000..7d5e71e7965 --- /dev/null +++ b/libjava/testsuite/libjava.mauve/mauve.exp @@ -0,0 +1,355 @@ +# Copyright (C) 1998, 1999 Cygnus Solutions. +# Written by Tom Tromey . +# Incorporate Mauve into libjava's DejaGNU test suite framework. + +# FIXME: should be able to compile from source as well as from .class. + + +# Compute list of files to compile. Returns list of all files +# representing classes that must be tested. Result parameter `uses' +# maps source file names onto list of objects required for link. +proc mauve_compute_uses {aName} { + upvar $aName uses + global env + + set fd [open classes r] + set line [read $fd] + close $fd + + foreach item [split $line] { + if {$item == ""} then { + continue + } + set item [join [split $item .] /].java + + # Look for Uses line in source file. + set fd [open $env(MAUVEDIR)/$item r] + set ufiles [list $item] + set dir [file dirname $item] + while {[gets $fd sline] != -1} { + if {[regsub -- {^// Uses:} $sline {} sline]} then { + foreach uf [split $sline] { + if {$uf != ""} then { + lappend ufiles $dir/$uf + } + } + } + } + close $fd + + set uses($item) {} + foreach file $ufiles { + set file [file rootname $file].o + lappend uses($item) $file + } + } + + return [lsort [array names uses]] +} + +# Run all the Mauve tests. +proc test_mauve {} { + global srcdir subdir env + + if {! [info exists env(MAUVEDIR)]} then { + verbose "MAUVEDIR not set; not running Mauve tests" + return + } + + # Run in subdir so we don't overwrite our own Makefile. + catch {system "rm -rf mauve-build"} + file mkdir mauve-build + # Some weirdness to set srcdir correctly. + set here [pwd] + cd $srcdir + set full_srcdir [pwd] + cd $here/mauve-build + + if {[catch {system "$env(MAUVEDIR)/configure --with-gcj"} msg]} then { + fail "Mauve configure" + verbose "configure failed with $msg" + return + } + pass "Mauve configure" + + # Copy appropriate tags file locally. + set fd [open $full_srcdir/../mauve-libgcj r] + set c [read $fd] + close $fd + set fd [open mauve-libgcj w] + puts -nonewline $fd $c + close $fd + + if {[catch {system "make KEYS=libjava classes.stamp"} msg]} then { + fail "Mauve build" + verbose "build failed with $msg" + return + } + pass "Mauve build" + + set srcfile $full_srcdir/$subdir/DejaGNUTestHarness.java + if {! [bytecompile_file $srcfile [pwd] $env(MAUVEDIR):[pwd]]} then { + fail "Compile DejaGNUTestHarness.java" + return + } + pass "Compile DejaGNUTestHarness.java" + + # Compute list of files to test, and also all files to build. + set choices [mauve_compute_uses uses] + + # Compute flags to use to do the build. + set compile_args [libjava_arguments] + set link_args [concat $compile_args \ + [list "additional_flags=--main=DejaGNUTestHarness"]] + + set ok 1 + set objlist {} + foreach base {DejaGNUTestHarness gnu/testlet/SimpleTestHarness gnu/testlet/TestHarness gnu/testlet/Testlet gnu/testlet/ResourceNotFoundException gnu/testlet/config} { + set file $base.class + set obj $base.o + if {[target_compile [pwd]/$file $obj object $compile_args] != ""} then { + fail "Compile $obj" + set ok 0 + } else { + pass "Compile $obj" + } + lappend objlist $obj + } + if {! $ok} then { + return + } + + set Executable DejaGNUTestHarness + foreach file $choices { + # Turn `java/lang/Foo.java' into `java.lang.Foo'. + set class [file rootname $file] + regsub -all -- / $class . class + + set ok 1 + foreach obj $uses($file) { + if {! [file exists $obj]} then { + verbose "compiling $obj for test of $class" + set srcfile [file rootname $obj].class + if {[target_compile [pwd]/$srcfile $obj object $compile_args] + != ""} then { + fail "Compile $obj for $class" + set ok 0 + break + } + pass "Compile $obj for $class" + } + } + if {! $ok} then { + continue + } + + if {[target_compile [concat $uses($file) $objlist] \ + $Executable executable $link_args] != ""} then { + fail "Link for $class" + continue + } + pass "Link for $class" + + set result [libjava_load [pwd]/DejaGNUTestHarness \ + "$env(MAUVEDIR) $class" ""] + if {[lindex $result 0] != "pass"} then { + fail "Execute for $class" + continue + } + + # Test for an exception thrown in the test harness itself. This + # isn't enough to test for all faults in the test harness, but + # it's better than nothing. + set output [lindex $result 1]; + if [regexp "Exception: " $output] then { + fail $output + continue + } + + pass "Execute for $class" + + # Extract pass/failure info from output. + foreach line [split [lindex $result 1] \n] { + if {[regexp -- {^(PASS|FAIL): (.*)$} $line ignore what msg]} then { + if {$what == "PASS"} then { + pass $msg + } else { + fail $msg + } + } + } + } +} + +# Run all the Mauve tests in a sim environment. In this case, the +# program cannot use argv[] because there's no way to pass in the +# command line, so tha name of the class to test is substituted by +# patching the source of the DejaGNUTestHarness. +proc test_mauve_sim {} { + global srcdir subdir env + + if {! [info exists env(MAUVEDIR)]} then { + verbose "MAUVEDIR not set; not running Mauve tests" + return + } + + # Run in subdir so we don't overwrite our own Makefile. + catch {system "rm -rf mauve-build"} + file mkdir mauve-build + # Some weirdness to set srcdir correctly. + set here [pwd] + cd $srcdir + set full_srcdir [pwd] + cd $here/mauve-build + + if {[catch {system "$env(MAUVEDIR)/configure --with-gcj"} msg]} then { + fail "Mauve configure" + verbose "configure failed with $msg" + return + } + pass "Mauve configure" + + # Copy appropriate tags file locally. + set fd [open $full_srcdir/../mauve-libgcj r] + set c [read $fd] + close $fd + set fd [open mauve-libgcj w] + puts -nonewline $fd $c + close $fd + + if {[catch {system "make KEYS=libjava classes.stamp"} msg]} then { + fail "Mauve build" + verbose "build failed with $msg" + return + } + pass "Mauve build" + + # Compute list of files to test, and also all files to build. + set choices [mauve_compute_uses uses] + + # Compute flags to use to do the build. + set compile_args [libjava_arguments] + set link_args [concat $compile_args \ + [list "additional_flags=--main=DejaGNUTestHarness"]] + + set ok 1 + set objlist {} + foreach base {gnu/testlet/SimpleTestHarness gnu/testlet/TestHarness \ + gnu/testlet/Testlet gnu/testlet/ResourceNotFoundException \ + gnu/testlet/config} { + set file $base.class + set obj $base.o + if {[target_compile [pwd]/$file $obj object $compile_args] != ""} then { + fail "Compile $obj" + set ok 0 + } else { + pass "Compile $obj" + } + lappend objlist $obj + } + if {! $ok} then { + return + } + + lappend objlist gnu/testlet/DejaGNUTestHarness.o + + set Executable DejaGNUTestHarness + foreach file $choices { + # Turn `java/lang/Foo.java' into `java.lang.Foo'. + + set class [file rootname $file] + regsub -all -- / $class . class + + set ok 1 + foreach obj $uses($file) { + if {! [file exists $obj]} then { + verbose "compiling $obj for test of $class" + set srcfile [file rootname $obj].class + if {[target_compile [pwd]/$srcfile $obj object $compile_args] + != ""} then { + fail "Compile $obj for $class" + set ok 0 + break + } + pass "Compile $obj for $class" + } + } + if {! $ok} then { + continue + } + + set infile $full_srcdir/$subdir/DejaGNUTestHarness.java + set srcfile DejaGNUTestHarness.java + set f [open $infile r] + set d [open gnu/testlet/$srcfile w] + while {[gets $f line] >= 0} { + if [regexp {harness\.runtest \(args\[1\]\)} $line] then { + regsub {args\[1\]} $line "\"$class\"" out + } else { + set out $line + } + puts $d $out + } + close $f + close $d + + if {! [bytecompile_file [pwd]/gnu/testlet/$srcfile [pwd]/gnu/testlet \ + $env(MAUVEDIR):[pwd]]} then { + fail "Compile DejaGNUTestHarness.java" + return + } + + if {[target_compile gnu/testlet/DejaGNUTestHarness.class \ + gnu/testlet/DejaGNUTestHarness.o object $compile_args] + != ""} then { + fail "Compile DejaGNUTestHarness.java" + continue + } + + if {[target_compile [concat $uses($file) $objlist] \ + $Executable executable $link_args] != ""} then { + fail "Link for $class" + continue + } + pass "Link for $class" + + set result [libjava_load [pwd]/DejaGNUTestHarness \ + "$env(MAUVEDIR) $class" ""] + if {[lindex $result 0] != "pass"} then { + fail "Execute for $class" + continue + } + + # Test for an exception thrown in the test harness itself. This + # isn't enough to test for all faults in the test harness, but + # it's better than nothing. + set output [lindex $result 1]; + if [regexp "Exception: " $output] then { + fail $output + continue + } + + pass "Execute for $class" + + # Extract pass/failure info from output. + foreach line [split [lindex $result 1] \n] { + if {[regexp -- {^(PASS|FAIL): (.*)$} $line ignore what msg]} then { + if {$what == "PASS"} then { + pass $msg + } else { + fail $msg + } + } + } + } +} + +# The test_mauve* procs will change the current directory. It's +# simpler to fix this up here than to keep track of this in the procs. +set here [pwd] +if { [board_info target exists is_simulator] } { + test_mauve_sim +} else { + test_mauve +} +cd $here