init

COPYING

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

JCGO

@@ -0,0 +1 @@
+Subproject commit b0a51c28c8b62c9a6329bad6c41533cb89a4ef85

README.md

@@ -0,0 +1,24 @@
+# deep-c-rsc
+runescape classic ported to C with SDL. utilizes
+[jcgo](https://github.com/ivmai/JCGO) to transpile the java to C, and patched
+with [SDL](https://libsdl.org/) for audio/video output and keyboard/mouse input.
+
+# build & run
+
+    $ sudo apt install openjdk-11-jre gcc libsdl2-dev
+    $ ./build.sh && ./mudclient
+
+## license
+Copyright 2021  2003Scape Team
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU Affero General Public License as published by the
+Free Software Foundation, either version 3 of the License, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License along
+with this program. If not, see http://www.gnu.org/licenses/.

build.sh

@@ -0,0 +1,12 @@
+java -jar ./JCGO/jcgo.jar mudclient -src ./mudclient204-headless \
+    @JCGO/stdpaths.in
+
+patch -p0 -i sdl.diff
+
+    #-DJCGO_PARALLEL
+    #-DJCGO_NOGJ
+gcc -g -I ./JCGO/include -I ./JCGO/native -I ./JCGO/include/boehmgc \
+    -DJCGO_USEGCJ -DJCGO_FPFAST -DJCGO_FASTMATH -DJCGO_INET  \
+    -DJCGO_INTFIT -DJCGO_THREADS -DJCGO_UNIX -D_IEEEFP_H -DJCGO_UNIFSYS \
+    -o mudclient jcgo_Out/Main.c -lm -lpthread -lSDL2 \
+    ./JCGO/libs/amd64/linux/libgcmt.a -no-pie

jcgo_Out/AbstInCh.c

@@ -0,0 +1,133 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_channels_spi_AbstractInterruptibleChannel
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_nio_channels_spi_AbstractInterruptibleChannel
+ CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__this__( java_nio_channels_spi_AbstractInterruptibleChannel
+ This )
+{
+ {
+  ;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__begin__( java_nio_channels_spi_AbstractInterruptibleChannel
+ This )
+{
+ {
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__close__( java_nio_channels_spi_AbstractInterruptibleChannel
+ This )
+{
+ {
+  if (!JCGO_FIELD_NZACCESS(This, closed))
+  {
+   JCGO_FIELD_NZACCESS(This, closed)= (jboolean)jtrue;
+   (JCGO_CALL_NZVFUNC(This)->implCloseChannel__(
+    This));
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__end__Z( java_nio_channels_spi_AbstractInterruptibleChannel
+ This, jboolean completed )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, closed))
+  {
+   JCGO_THROW_EXC(java_nio_channels_AsynchronousCloseException__new__());
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__isOpen__( java_nio_channels_spi_AbstractInterruptibleChannel
+ This )
+{
+ {
+  return (jboolean)(!JCGO_FIELD_NZACCESS(This, closed));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_nio_channels_spi_AbstractInterruptibleChannel_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_channels_spi_AbstractInterruptibleChannel__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_channels_spi_AbstractInterruptibleChannel,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ (jObject (CFASTCALL*)(jObject))java_nio_channels_spi_AbstractInterruptibleChannel__this__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_channels_spi_AbstractInterruptibleChannel_class_s
+ java_nio_channels_spi_AbstractInterruptibleChannel__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_channels_spi_AbstractInterruptibleChannel_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstInCh),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype670_Mdclnt jcgo_array2_AbstInCh=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 50,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)98/*'b'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)67/*'C'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)108/*'l'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstInCh
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_AbstInCh),
+ 0, 50, (jint)0x70b142aaL
+};
+
+#ifdef CHKALL_java_nio_channels_spi_AbstractInterruptibleChannel
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstInCh.h

@@ -0,0 +1,66 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_nio_channels_spi_AbstractInterruptibleChannel
+ CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__this__( java_nio_channels_spi_AbstractInterruptibleChannel
+ This );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__begin__( java_nio_channels_spi_AbstractInterruptibleChannel
+ This );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__close__( java_nio_channels_spi_AbstractInterruptibleChannel
+ This );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__end__Z( java_nio_channels_spi_AbstractInterruptibleChannel
+ This, jboolean completed );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_nio_channels_spi_AbstractInterruptibleChannel__isOpen__( java_nio_channels_spi_AbstractInterruptibleChannel
+ This );
+
+struct java_nio_channels_spi_AbstractInterruptibleChannel_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_channels_spi_AbstractInterruptibleChannel (CFASTCALL *jcgo_thisRtn)(
+  java_nio_channels_spi_AbstractInterruptibleChannel This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ void (CFASTCALL *implCloseChannel__)( java_nio_channels_spi_AbstractInterruptibleChannel
+  This );
+};
+
+struct java_nio_channels_spi_AbstractInterruptibleChannel_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_nio_channels_spi_AbstractInterruptibleChannel_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_channels_spi_AbstractInterruptibleChannel_class_s
+ java_nio_channels_spi_AbstractInterruptibleChannel__class;
+
+struct java_nio_channels_spi_AbstractInterruptibleChannel_s
+{
+ CONST struct java_nio_channels_spi_AbstractInterruptibleChannel_methods_s
+  *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jboolean closed;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype670_Mdclnt jcgo_array2_AbstInCh;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstInCh;
+
+#endif

jcgo_Out/AbstLs2C.c

@@ -0,0 +1,172 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_AbstractList
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList_2__void( java_util_AbstractList_2 This )
+{
+ JCGO_FIELD_NZACCESS(This, knownMod)= JCGO_FIELD_NZACCESS(JCGO_FIELD_NZACCESS(This,
+  this_0), modCount);
+ JCGO_FIELD_NZACCESS(This, position)= JCGO_FIELD_NZACCESS(This, val_index);
+ JCGO_FIELD_NZACCESS(This, lastReturned)= (-(jint)1);
+ JCGO_FIELD_NZACCESS(This, size)= (JCGO_CALL_NZVFUNC(JCGO_FIELD_NZACCESS(This,
+  this_0))->size__(
+  (java_util_AbstractCollection)JCGO_FIELD_NZACCESS(This, this_0)));
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList_2__checkMod__( java_util_AbstractList_2 This
+ )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, knownMod) != JCGO_FIELD_NZACCESS(JCGO_FIELD_NZACCESS(This,
+   this_0), modCount))
+  {
+   JCGO_THROW_EXC(java_util_ConcurrentModificationException__new__());
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractList_2__hasNext__( java_util_AbstractList_2 This
+ )
+{
+ {
+  return (jboolean)(JCGO_FIELD_NZACCESS(This, position) < JCGO_FIELD_NZACCESS(This,
+   size));
+ }
+}
+
+JCGO_NOSEP_STATIC java_lang_Object CFASTCALL
+java_util_AbstractList_2__next__( java_util_AbstractList_2 This )
+{
+ {
+  (java_util_AbstractList_2__checkMod__(
+   This));
+  if (JCGO_FIELD_NZACCESS(This, position) == JCGO_FIELD_NZACCESS(This,
+   size))
+  {
+   JCGO_THROW_EXC(java_util_NoSuchElementException__new__());
+  }
+  JCGO_FIELD_NZACCESS(This, lastReturned)= JCGO_FIELD_NZACCESS(This,
+   position);
+  return (JCGO_CALL_NZVFUNC(JCGO_FIELD_NZACCESS(This, this_0))->get__I(
+   JCGO_FIELD_NZACCESS(This, this_0), JCGO_FIELD_NZACCESS(This, position)++));
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_util_AbstractList_2__remove__( java_util_AbstractList_2 This
+ )
+{
+ {
+  (java_util_AbstractList_2__checkMod__(
+   This));
+  if (JCGO_FIELD_NZACCESS(This, lastReturned) < 0)
+  {
+   JCGO_THROW_EXC(java_lang_IllegalStateException__new__());
+  }
+  (JCGO_CALL_NZVFUNC(JCGO_FIELD_NZACCESS(This, this_0))->remove__I(
+   JCGO_FIELD_NZACCESS(This, this_0), JCGO_FIELD_NZACCESS(This, lastReturned)));
+  JCGO_FIELD_NZACCESS(This, size)--;
+  JCGO_FIELD_NZACCESS(This, position)= JCGO_FIELD_NZACCESS(This, lastReturned);
+  JCGO_FIELD_NZACCESS(This, lastReturned)= (-(jint)1);
+  JCGO_FIELD_NZACCESS(This, knownMod)= JCGO_FIELD_NZACCESS(JCGO_FIELD_NZACCESS(This,
+   this_0), modCount);
+ }
+}
+
+JCGO_NOSEP_INLINE java_util_AbstractList_2 CFASTCALL
+java_util_AbstractList_2__this__L8rnj6I( java_util_AbstractList_2
+ This, java_util_AbstractList this_0, jint val_index )
+{
+ {
+  JCGO_FIELD_NZACCESS(This, this_0)= this_0;
+  JCGO_FIELD_NZACCESS(This, val_index)= val_index;
+  java_util_AbstractList_2__void(This);
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_util_AbstractList_2 CFASTCALL
+java_util_AbstractList_2__new__L8rnj6I( java_util_AbstractList this_0,
+ jint val_index )
+{
+ return java_util_AbstractList_2__this__L8rnj6I(
+  (java_util_AbstractList_2)jcgo_newObject((jvtable)&java_util_AbstractList_2_methods),
+  this_0, val_index);
+}
+
+JCGO_NOSEP_DATA CONST struct java_util_AbstractList_2_methods_s java_util_AbstractList_2_methods=
+{
+ JCGO_CLASSREF_OF(java_util_AbstractList_2__class),
+ JCGO_GCJDESCR_INIT(java_util_AbstractList_2_s, this_0)
+ OBJT_java_util_AbstractList_2,
+ (JCGO_OBJSIZE_T)sizeof(struct java_util_AbstractList_2_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Object__toString__,
+ java_lang_Object__finalize__,
+ java_util_AbstractList_2__hasNext__,
+ java_util_AbstractList_2__next__,
+ java_util_AbstractList_2__remove__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_AbstractList_2_class_s
+ java_util_AbstractList_2__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_AbstractList_2_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstLs2C),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array2_EntrItrt)),
+  0x0
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype94_GmCnnctn jcgo_array2_AbstLs2C=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 24,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)76/*'L'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)115/*'s'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)36/*'$'*/, (jbyte)(jchar)50/*'2'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstLs2C
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_AbstLs2C),
+ 0, 24, (jint)0x88583a2eL
+};
+
+#ifdef CHKALL_java_util_AbstractList
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstLs2C.h

@@ -0,0 +1,77 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList_2__void( java_util_AbstractList_2 This );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList_2__checkMod__( java_util_AbstractList_2 This
+ );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractList_2__hasNext__( java_util_AbstractList_2 This
+ );
+
+JCGO_NOSEP_STATIC java_lang_Object CFASTCALL
+java_util_AbstractList_2__next__( java_util_AbstractList_2 This );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_util_AbstractList_2__remove__( java_util_AbstractList_2 This
+ );
+
+JCGO_NOSEP_INLINE java_util_AbstractList_2 CFASTCALL
+java_util_AbstractList_2__this__L8rnj6I( java_util_AbstractList_2
+ This, java_util_AbstractList this_0, jint val_index );
+JCGO_NOSEP_FRWINL java_util_AbstractList_2 CFASTCALL
+java_util_AbstractList_2__new__L8rnj6I( java_util_AbstractList this_0,
+ jint val_index );
+
+struct java_util_AbstractList_2_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_AbstractList_2 (CFASTCALL *jcgo_thisRtn)( java_util_AbstractList_2
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *hasNext__)( java_util_AbstractList_2 This );
+ java_lang_Object (CFASTCALL *next__)( java_util_AbstractList_2 This
+  );
+ void (CFASTCALL *remove__)( java_util_AbstractList_2 This );
+};
+
+struct java_util_AbstractList_2_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_util_AbstractList_2_methods_s java_util_AbstractList_2_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_AbstractList_2_class_s
+ java_util_AbstractList_2__class;
+
+struct java_util_AbstractList_2_s
+{
+ CONST struct java_util_AbstractList_2_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_util_AbstractList this_0;
+ jint val_index;
+ jint knownMod;
+ jint position;
+ jint lastReturned;
+ jint size;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype94_GmCnnctn jcgo_array2_AbstLs2C;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstLs2C;
+
+#endif

jcgo_Out/AbstLsDC.c

@@ -0,0 +1,151 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_AbstractList
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList_1__void( java_util_AbstractList_1 This )
+{
+ JCGO_FIELD_NZACCESS(This, size)= (JCGO_CALL_NZVFUNC(JCGO_FIELD_NZACCESS(This,
+  this_0))->size__(
+  (java_util_AbstractCollection)JCGO_FIELD_NZACCESS(This, this_0)));
+ JCGO_FIELD_NZACCESS(This, last)= (-(jint)1);
+ JCGO_FIELD_NZACCESS(This, knownMod)= JCGO_FIELD_NZACCESS(JCGO_FIELD_NZACCESS(This,
+  this_0), modCount);
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList_1__checkMod__( java_util_AbstractList_1 This
+ )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, knownMod) != JCGO_FIELD_NZACCESS(JCGO_FIELD_NZACCESS(This,
+   this_0), modCount))
+  {
+   JCGO_THROW_EXC(java_util_ConcurrentModificationException__new__());
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractList_1__hasNext__( java_util_AbstractList_1 This
+ )
+{
+ {
+  return (jboolean)(JCGO_FIELD_NZACCESS(This, pos) < JCGO_FIELD_NZACCESS(This,
+   size));
+ }
+}
+
+JCGO_NOSEP_STATIC java_lang_Object CFASTCALL
+java_util_AbstractList_1__next__( java_util_AbstractList_1 This )
+{
+ {
+  (java_util_AbstractList_1__checkMod__(
+   This));
+  if (JCGO_FIELD_NZACCESS(This, pos) == JCGO_FIELD_NZACCESS(This, size))
+  {
+   JCGO_THROW_EXC(java_util_NoSuchElementException__new__());
+  }
+  JCGO_FIELD_NZACCESS(This, last)= JCGO_FIELD_NZACCESS(This, pos);
+  return (JCGO_CALL_NZVFUNC(JCGO_FIELD_NZACCESS(This, this_0))->get__I(
+   JCGO_FIELD_NZACCESS(This, this_0), JCGO_FIELD_NZACCESS(This, pos)++));
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_util_AbstractList_1__remove__( java_util_AbstractList_1 This
+ )
+{
+ {
+  (java_util_AbstractList_1__checkMod__(
+   This));
+  if (JCGO_FIELD_NZACCESS(This, last) < 0)
+  {
+   JCGO_THROW_EXC(java_lang_IllegalStateException__new__());
+  }
+  (JCGO_CALL_NZVFUNC(JCGO_FIELD_NZACCESS(This, this_0))->remove__I(
+   JCGO_FIELD_NZACCESS(This, this_0), JCGO_FIELD_NZACCESS(This, last)));
+  JCGO_FIELD_NZACCESS(This, pos)--;
+  JCGO_FIELD_NZACCESS(This, size)--;
+  JCGO_FIELD_NZACCESS(This, last)= (-(jint)1);
+  JCGO_FIELD_NZACCESS(This, knownMod)= JCGO_FIELD_NZACCESS(JCGO_FIELD_NZACCESS(This,
+   this_0), modCount);
+ }
+}
+
+JCGO_NOSEP_STATIC java_util_AbstractList_1 CFASTCALL
+java_util_AbstractList_1__this__L8rnj6( java_util_AbstractList_1 This,
+ java_util_AbstractList this_0 )
+{
+ {
+  JCGO_FIELD_NZACCESS(This, this_0)= this_0;
+  java_util_AbstractList_1__void(This);
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_util_AbstractList_1 CFASTCALL
+java_util_AbstractList_1__new__L8rnj6( java_util_AbstractList this_0
+ )
+{
+ return java_util_AbstractList_1__this__L8rnj6(
+  (java_util_AbstractList_1)jcgo_newObject((jvtable)&java_util_AbstractList_1_methods),
+  this_0);
+}
+
+JCGO_NOSEP_DATA CONST struct java_util_AbstractList_1_methods_s java_util_AbstractList_1_methods=
+{
+ JCGO_CLASSREF_OF(java_util_AbstractList_1__class),
+ JCGO_GCJDESCR_INIT(java_util_AbstractList_1_s, this_0)
+ OBJT_java_util_AbstractList_1,
+ (JCGO_OBJSIZE_T)sizeof(struct java_util_AbstractList_1_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Object__toString__,
+ java_lang_Object__finalize__,
+ java_util_AbstractList_1__hasNext__,
+ java_util_AbstractList_1__next__,
+ java_util_AbstractList_1__remove__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_AbstractList_1_class_s
+ java_util_AbstractList_1__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_AbstractList_1_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstLsDC),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array2_EntrItrt)),
+  0x0
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstLsDC
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array5_AbstrcLs),
+ 0, 24, (jint)0x88583a2dL
+};
+
+#ifdef CHKALL_java_util_AbstractList
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstLsDC.h

@@ -0,0 +1,74 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList_1__void( java_util_AbstractList_1 This );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList_1__checkMod__( java_util_AbstractList_1 This
+ );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractList_1__hasNext__( java_util_AbstractList_1 This
+ );
+
+JCGO_NOSEP_STATIC java_lang_Object CFASTCALL
+java_util_AbstractList_1__next__( java_util_AbstractList_1 This );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_util_AbstractList_1__remove__( java_util_AbstractList_1 This
+ );
+
+JCGO_NOSEP_STATIC java_util_AbstractList_1 CFASTCALL
+java_util_AbstractList_1__this__L8rnj6( java_util_AbstractList_1 This,
+ java_util_AbstractList this_0 );
+JCGO_NOSEP_FRWINL java_util_AbstractList_1 CFASTCALL
+java_util_AbstractList_1__new__L8rnj6( java_util_AbstractList this_0
+ );
+
+struct java_util_AbstractList_1_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_AbstractList_1 (CFASTCALL *jcgo_thisRtn)( java_util_AbstractList_1
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *hasNext__)( java_util_AbstractList_1 This );
+ java_lang_Object (CFASTCALL *next__)( java_util_AbstractList_1 This
+  );
+ void (CFASTCALL *remove__)( java_util_AbstractList_1 This );
+};
+
+struct java_util_AbstractList_1_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_util_AbstractList_1_methods_s java_util_AbstractList_1_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_AbstractList_1_class_s
+ java_util_AbstractList_1__class;
+
+struct java_util_AbstractList_1_s
+{
+ CONST struct java_util_AbstractList_1_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_util_AbstractList this_0;
+ jint pos;
+ jint size;
+ jint last;
+ jint knownMod;
+};
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstLsDC;
+
+#endif

jcgo_Out/AbstSlCh.c

@@ -0,0 +1,174 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_channels_spi_AbstractSelectableChannel
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__void( java_nio_channels_spi_AbstractSelectableChannel
+ This )
+{
+ JCGO_FIELD_NZACCESS(This, blocking)= jtrue;
+ JCGO_FIELD_NZACCESS(This, LOCK)= java_lang_Object__new__();
+ JCGO_FIELD_NZACCESS(This, keys)= java_util_LinkedList__new__();
+}
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__blockingLock__( java_nio_channels_spi_AbstractSelectableChannel
+ This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, LOCK);
+ }
+}
+
+JCGO_NOSEP_INLINE java_nio_channels_spi_AbstractSelectableChannel
+ CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__this__L6sfa6( java_nio_channels_spi_AbstractSelectableChannel
+ This, java_nio_channels_spi_SelectorProvider provider )
+{
+ {
+  (java_nio_channels_SelectableChannel__this__((java_nio_channels_SelectableChannel)This));
+  java_nio_channels_spi_AbstractSelectableChannel__void(This);
+  (void)provider;
+ }
+ return This;
+}
+
+JCGO_NOSEP_STATIC java_nio_channels_SelectableChannel CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__configureBlocking__Z(
+ java_nio_channels_spi_AbstractSelectableChannel This, jboolean blocking
+ )
+{
+ {
+  {
+   JCGO_SYNC_BLOCK((java_nio_channels_spi_AbstractSelectableChannel__blockingLock__(
+    This)))
+   {
+    if (JCGO_FIELD_NZACCESS(This, blocking) != blocking)
+    {
+     (gnu_java_nio_SocketChannelImpl__implConfigureBlocking__Z(
+      (gnu_java_nio_SocketChannelImpl)This, (jboolean)blocking));
+     JCGO_FIELD_NZACCESS(This, blocking)= (jboolean)blocking;
+    }
+   }
+   JCGO_SYNC_END
+  }
+  return (java_nio_channels_SelectableChannel)This;
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__implCloseChannel__(
+ java_nio_channels_spi_AbstractSelectableChannel This )
+{
+ {
+  {
+   JCGO_TRY_BLOCK
+   {
+    (gnu_java_nio_SocketChannelImpl__implCloseSelectableChannel__(
+     (gnu_java_nio_SocketChannelImpl)This));
+   }
+   JCGO_TRY_LEAVE
+   {
+    jObject jcgo_rcvrL1;
+    {
+     java_util_Iterator it;
+     it= (jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This, keys), JCGO_CALL_FINALF((java_util_LinkedList)jcgo_rcvrL1)
+      java_util_AbstractSequentialList__iterator__(
+      (java_util_AbstractSequentialList)jcgo_rcvrL1));
+     for (; (JCGO_CALL_VFUNC(it)->hasNext__(
+      it));)
+     {
+      (JCGO_CALL_FINALF(((java_lang_Object)JCGO_CAST_OBJECT0(OBJT_jboolean,
+       MAXT_jboolean, (JCGO_CALL_NZVFUNC(it)->next__(
+       it))))) (void)0);
+     }
+    }
+   }
+   JCGO_TRY_FINALLYEND
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__isBlocking__( java_nio_channels_spi_AbstractSelectableChannel
+ This )
+{
+ {
+  return (jboolean)JCGO_FIELD_NZACCESS(This, blocking);
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_nio_channels_spi_AbstractSelectableChannel_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_channels_spi_AbstractSelectableChannel__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_channels_spi_AbstractSelectableChannel,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_channels_spi_AbstractSelectableChannel_class_s
+ java_nio_channels_spi_AbstractSelectableChannel__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_channels_spi_AbstractSelectableChannel_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstSlCh),
+  JCGO_CLASSREF_OF(java_nio_channels_SelectableChannel__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype109_GmCnnctn jcgo_array2_AbstSlCh=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 47,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)83/*'S'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)98/*'b'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)67/*'C'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)108/*'l'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstSlCh
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_AbstSlCh),
+ 0, 47, (jint)0xb4fce0b1L
+};
+
+#ifdef CHKALL_java_nio_channels_spi_AbstractSelectableChannel
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstSlCh.h

@@ -0,0 +1,74 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__void( java_nio_channels_spi_AbstractSelectableChannel
+ This );
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__blockingLock__( java_nio_channels_spi_AbstractSelectableChannel
+ This );
+
+JCGO_NOSEP_INLINE java_nio_channels_spi_AbstractSelectableChannel
+ CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__this__L6sfa6( java_nio_channels_spi_AbstractSelectableChannel
+ This, java_nio_channels_spi_SelectorProvider provider );
+
+JCGO_NOSEP_STATIC java_nio_channels_SelectableChannel CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__configureBlocking__Z(
+ java_nio_channels_spi_AbstractSelectableChannel This, jboolean blocking
+ );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__implCloseChannel__(
+ java_nio_channels_spi_AbstractSelectableChannel This );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_nio_channels_spi_AbstractSelectableChannel__isBlocking__( java_nio_channels_spi_AbstractSelectableChannel
+ This );
+
+struct java_nio_channels_spi_AbstractSelectableChannel_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_channels_spi_AbstractSelectableChannel (CFASTCALL *jcgo_thisRtn)(
+  java_nio_channels_spi_AbstractSelectableChannel This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ void (CFASTCALL *implCloseChannel__)( java_nio_channels_spi_AbstractSelectableChannel
+  This );
+};
+
+struct java_nio_channels_spi_AbstractSelectableChannel_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_nio_channels_spi_AbstractSelectableChannel_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_channels_spi_AbstractSelectableChannel_class_s
+ java_nio_channels_spi_AbstractSelectableChannel__class;
+
+struct java_nio_channels_spi_AbstractSelectableChannel_s
+{
+ CONST struct java_nio_channels_spi_AbstractSelectableChannel_methods_s
+  *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jboolean closed;
+ java_lang_Object LOCK;
+ java_util_LinkedList keys;
+ jboolean blocking;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype109_GmCnnctn jcgo_array2_AbstSlCh;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstSlCh;
+
+#endif

jcgo_Out/AbstSqLs.c

@@ -0,0 +1,93 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_AbstractSequentialList
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_util_AbstractSequentialList CFASTCALL
+java_util_AbstractSequentialList__this__( java_util_AbstractSequentialList
+ This )
+{
+ {
+  (java_util_AbstractList__this__((java_util_AbstractList)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_util_Iterator CFASTCALL
+java_util_AbstractSequentialList__iterator__( java_util_AbstractSequentialList
+ This )
+{
+ {
+  return (java_util_Iterator)(java_util_AbstractList__listIterator__(
+   (java_util_AbstractList)This));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_util_AbstractSequentialList_methods=
+{
+ JCGO_CLASSREF_OF(java_util_AbstractSequentialList__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_util_AbstractSequentialList,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ (jObject (CFASTCALL*)(jObject))java_util_AbstractSequentialList__this__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_AbstractSequentialList_class_s
+ java_util_AbstractSequentialList__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_AbstractSequentialList_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstSqLs),
+  JCGO_CLASSREF_OF(java_util_AbstractList__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype98_GmCnnctn jcgo_array2_AbstSqLs=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 32,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)83/*'S'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)113/*'q'*/,
+   (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)76/*'L'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstSqLs
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_AbstSqLs),
+ 0, 32, (jint)0x51280bfL
+};
+
+#ifdef CHKALL_java_util_AbstractSequentialList
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstSqLs.h

@@ -0,0 +1,71 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_util_AbstractSequentialList CFASTCALL
+java_util_AbstractSequentialList__this__( java_util_AbstractSequentialList
+ This );
+
+JCGO_NOSEP_FRWINL java_util_Iterator CFASTCALL
+java_util_AbstractSequentialList__iterator__( java_util_AbstractSequentialList
+ This );
+
+struct java_util_AbstractSequentialList_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_AbstractSequentialList (CFASTCALL *jcgo_thisRtn)( java_util_AbstractSequentialList
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_util_AbstractList This, java_lang_Object
+  o );
+ jint (CFASTCALL *hashCode__)( java_util_AbstractList This );
+ java_lang_String (CFASTCALL *toString__)( java_util_AbstractCollection
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *isEmpty__)( java_util_AbstractCollection This
+  );
+ java_util_Iterator (CFASTCALL *iterator__)( java_util_AbstractSequentialList
+  This );
+ jint (CFASTCALL *size__)( java_util_AbstractCollection This );
+ jboolean (CFASTCALL *add__Lo)( java_util_AbstractList This, java_lang_Object
+  o );
+ jboolean (CFASTCALL *contains__Lo)( java_util_AbstractCollection This,
+  java_lang_Object o );
+ jboolean (CFASTCALL *containsAll__L07mt2)( java_util_AbstractCollection
+  This, java_util_Collection c );
+ java_lang_Object (CFASTCALL *get__I)( java_util_AbstractSequentialList
+  This, jint index );
+ void (CFASTCALL *add__ILo)( java_util_AbstractSequentialList This,
+  java_lang_Object o, jint index );
+ java_util_Iterator (CFASTCALL *listIterator__I)( java_util_AbstractSequentialList
+  This, jint index );
+ java_lang_Object (CFASTCALL *remove__I)( java_util_AbstractSequentialList
+  This, jint index );
+};
+
+struct java_util_AbstractSequentialList_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_util_AbstractSequentialList_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_AbstractSequentialList_class_s
+ java_util_AbstractSequentialList__class;
+
+struct java_util_AbstractSequentialList_s
+{
+ CONST struct java_util_AbstractSequentialList_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ jint modCount;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype98_GmCnnctn jcgo_array2_AbstSqLs;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstSqLs;
+
+#endif

jcgo_Out/AbstrcCl.c

@@ -0,0 +1,263 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_AbstractCollection
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__add__Lo( java_util_AbstractCollection
+ This, java_lang_Object o )
+{
+ {
+  JCGO_THROW_EXC(java_lang_UnsupportedOperationException__new__());
+ }
+ return (jboolean)0;
+}
+
+JCGO_NOSEP_STATIC java_util_AbstractCollection CFASTCALL
+java_util_AbstractCollection__this__( java_util_AbstractCollection
+ This )
+{
+ {
+  ;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__addAll__L07mt2( java_util_AbstractCollection
+ This, java_util_Collection c )
+{
+ {
+  java_util_Iterator itr;
+  jint pos;
+  jboolean modified;
+  itr= (JCGO_CALL_VFUNC(c)->iterator__(
+   c));
+  modified= jfalse;
+  pos= (JCGO_CALL_NZVFUNC(c)->size__(
+   c));
+  while (--pos >= 0)
+  {
+   modified|= (jboolean)(JCGO_CALL_NZVFUNC(This)->add__Lo(
+    This, (JCGO_CALL_VFUNC(itr)->next__(
+    itr))));
+  }
+  return (jboolean)modified;
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__containsAll__L07mt2( java_util_AbstractCollection
+ This, java_util_Collection c )
+{
+ {
+  java_util_Iterator itr;
+  jint pos;
+  itr= (JCGO_CALL_VFUNC(c)->iterator__(
+   c));
+  pos= (JCGO_CALL_NZVFUNC(c)->size__(
+   c));
+  while (--pos >= 0)
+  {
+   if (!(JCGO_CALL_NZVFUNC(This)->contains__Lo(
+    This, (JCGO_CALL_VFUNC(itr)->next__(
+    itr)))))
+   {
+    return (jboolean)jfalse;
+   }
+  }
+  return (jboolean)jtrue;
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__isEmpty__( java_util_AbstractCollection
+ This )
+{
+ {
+  return (jboolean)((JCGO_CALL_NZVFUNC(This)->size__(
+   This)) == 0);
+ }
+}
+
+JCGO_NOSEP_STATIC java_lang_String CFASTCALL
+java_util_AbstractCollection__toString__( java_util_AbstractCollection
+ This )
+{
+ {
+  java_util_Iterator itr;
+  java_lang_StringBuilder r;
+  jint pos;
+  struct java_lang_StringBuilder_s jcgo_stackobj1;
+  itr= (JCGO_CALL_NZVFUNC(This)->iterator__(
+   This));
+  r= (java_lang_StringBuilder__this__Ls(
+   JCGO_STACKOBJ_NEW(jcgo_stackobj1, java_lang_StringBuilder_methods),
+   JCGO_STRREF_OF(jcgo_string2_AbstrcCl)));
+  pos= (JCGO_CALL_NZVFUNC(This)->size__(
+   This));
+  while (--pos >= 0)
+  {
+   java_lang_Object o;
+   o= (JCGO_CALL_VFUNC(itr)->next__(
+    itr));
+   if (o == (java_lang_Object)This)
+   {
+    (java_lang_StringBuilder__append__Ls(
+     r, JCGO_STRREF_OF(jcgo_string3_AbstrcCl)));
+   }
+   else
+   {
+    (java_lang_StringBuilder__append__Lo(
+     r, o));
+   }
+   if (pos > 0)
+   {
+    (java_lang_StringBuilder__append__Ls(
+     r, JCGO_STRREF_OF(jcgo_string4_Hshtbl)));
+   }
+  }
+  (java_lang_StringBuilder__append__C(
+   r, (jchar)93/*']'*/));
+  return (java_lang_StringBuilder__toString__(
+   r));
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__equals__LoLo( java_lang_Object o1, java_lang_Object
+ o2 )
+{
+ {
+  return (jboolean)(o1 == jnull? o2 == jnull : (JCGO_CALL_NZVFUNC(o1)->equals__Lo(
+   o1, o2)));
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_AbstractCollection__hashCode__Lo( java_lang_Object o )
+{
+ {
+  return o == jnull? 0 : (JCGO_CALL_NZVFUNC(o)->hashCode__(
+   o));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_util_AbstractCollection_methods=
+{
+ JCGO_CLASSREF_OF(java_util_AbstractCollection__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_util_AbstractCollection,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ (jObject (CFASTCALL*)(jObject))java_util_AbstractCollection__this__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_AbstractCollection_class_s
+ java_util_AbstractCollection__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_AbstractCollection_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstrcCl),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array4_AbstrcCl)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype2_GameMdl jcgo_array4_AbstrcCl=
+{
+ (jvtable)&jObjectArr_methods,
+ JCGO_MON_INIT
+ 1,
+ JCGO_CLASSREF_OF(java_lang_Class__class),
+ {
+  (jObject)JCGO_CLASSREF_OF(java_util_Collection__class)
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype90_GmCnnctn jcgo_array5_AbstrcCl=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 28,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)67/*'C'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)99/*'c'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype2_BZLib jcgo_array6_AbstrcCl=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 6,
+ {
+  (jbyte)(jchar)91/*'['*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)109/*'m'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)61/*'='*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype2_BZLib jcgo_array7_AbstrcCl=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 6,
+ {
+  (jbyte)(jchar)60/*'<'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)62/*'>'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstrcCl
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array5_AbstrcCl),
+ 0, 28, (jint)0xa6b2d220L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_AbstrcCl
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array6_AbstrcCl),
+ 0, 1, (jint)0x5bL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_AbstrcCl
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array7_AbstrcCl),
+ 0, 6, (jint)0x6cf64aa4L
+};
+
+#ifdef CHKALL_java_util_AbstractCollection
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstrcCl.h

@@ -0,0 +1,95 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__add__Lo( java_util_AbstractCollection
+ This, java_lang_Object o );
+
+JCGO_NOSEP_STATIC java_util_AbstractCollection CFASTCALL
+java_util_AbstractCollection__this__( java_util_AbstractCollection
+ This );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__addAll__L07mt2( java_util_AbstractCollection
+ This, java_util_Collection c );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__containsAll__L07mt2( java_util_AbstractCollection
+ This, java_util_Collection c );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__isEmpty__( java_util_AbstractCollection
+ This );
+
+JCGO_NOSEP_STATIC java_lang_String CFASTCALL
+java_util_AbstractCollection__toString__( java_util_AbstractCollection
+ This );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractCollection__equals__LoLo( java_lang_Object o1, java_lang_Object
+ o2 );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_AbstractCollection__hashCode__Lo( java_lang_Object o );
+
+struct java_util_AbstractCollection_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_AbstractCollection (CFASTCALL *jcgo_thisRtn)( java_util_AbstractCollection
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_util_AbstractCollection
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *isEmpty__)( java_util_AbstractCollection This
+  );
+ java_util_Iterator (CFASTCALL *iterator__)( java_util_AbstractCollection
+  This );
+ jint (CFASTCALL *size__)( java_util_AbstractCollection This );
+ jboolean (CFASTCALL *add__Lo)( java_util_AbstractCollection This,
+  java_lang_Object o );
+ jboolean (CFASTCALL *contains__Lo)( java_util_AbstractCollection This,
+  java_lang_Object o );
+ jboolean (CFASTCALL *containsAll__L07mt2)( java_util_AbstractCollection
+  This, java_util_Collection c );
+};
+
+struct java_util_AbstractCollection_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_util_AbstractCollection_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_AbstractCollection_class_s
+ java_util_AbstractCollection__class;
+
+struct java_util_AbstractCollection_s
+{
+ CONST struct java_util_AbstractCollection_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype2_GameMdl jcgo_array4_AbstrcCl;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype90_GmCnnctn jcgo_array5_AbstrcCl;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype2_BZLib jcgo_array6_AbstrcCl;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype2_BZLib jcgo_array7_AbstrcCl;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstrcCl;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_AbstrcCl;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_AbstrcCl;
+
+#endif

jcgo_Out/AbstrcLs.c

@@ -0,0 +1,279 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_AbstractList
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList__add__ILo( java_util_AbstractList This, java_lang_Object
+ o, jint index )
+{
+ {
+  JCGO_THROW_EXC(java_lang_UnsupportedOperationException__new__());
+ }
+}
+
+JCGO_NOSEP_FRWINL java_util_Iterator CFASTCALL
+java_util_AbstractList__iterator__( java_util_AbstractList This )
+{
+ {
+  return (java_util_Iterator)(java_util_AbstractList_1__new__L8rnj6(
+   This));
+ }
+}
+
+JCGO_NOSEP_INLINE java_util_Iterator CFASTCALL
+java_util_AbstractList__listIterator__I( java_util_AbstractList This,
+ jint index )
+{
+ {
+  if (index < 0 || index > (JCGO_CALL_NZVFUNC(This)->size__(
+   (java_util_AbstractCollection)This)))
+  {
+   jObject jcgo_rcvrL1;
+   struct java_lang_StringBuilder_s jcgo_stackobj1;
+   struct java_lang_String_s jcgo_stackobj2;
+   struct java_lang_String_s jcgo_stackobj3;
+   JCGO_THROW_EXC((java_lang_IndexOutOfBoundsException__new__Ls(
+    (jcgo_rcvrL1= (jObject)java_lang_StringBuilder__append__Ls(
+    java_lang_StringBuilder__append__Ls(
+    java_lang_StringBuilder__append__Ls(
+    java_lang_StringBuilder__this__(
+    JCGO_STACKOBJ_NEW(jcgo_stackobj1, java_lang_StringBuilder_methods)),
+    JCGO_STRREF_OF(jcgo_string2_AbstrcLs)), (java_lang_String__valueOf__IX(
+    index, JCGO_STACKOBJ_NEW(jcgo_stackobj2, java_lang_String_methods)))),
+    JCGO_STRREF_OF(jcgo_string3_AbstrcLs)), java_lang_String__new__L5dy9e(
+    java_lang_StringBuilder__append__Ls(
+    (java_lang_StringBuilder)jcgo_rcvrL1, (java_lang_String__valueOf__IX(
+    (JCGO_CALL_NZVFUNC(This)->size__(
+    (java_util_AbstractCollection)This)), JCGO_STACKOBJ_NEW(jcgo_stackobj3,
+    java_lang_String_methods)))))))));
+  }
+  return (java_util_Iterator)(java_util_AbstractList_2__new__L8rnj6I(
+   This, index));
+ }
+}
+
+JCGO_NOSEP_STATIC java_util_AbstractList CFASTCALL
+java_util_AbstractList__this__( java_util_AbstractList This )
+{
+ {
+  (java_util_AbstractCollection__this__((java_util_AbstractCollection)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractList__add__Lo( java_util_AbstractList This, java_lang_Object
+ o )
+{
+ {
+  (JCGO_CALL_NZVFUNC(This)->add__ILo(
+   This, o, (JCGO_CALL_NZVFUNC(This)->size__(
+   (java_util_AbstractCollection)This))));
+  return (jboolean)jtrue;
+ }
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractList__equals__Lo( java_util_AbstractList This, java_lang_Object
+ o )
+{
+ {
+  java_util_Iterator itr1;
+  java_util_Iterator itr2;
+  jint size;
+  if (o == (java_lang_Object)This)
+  {
+   return (jboolean)jtrue;
+  }
+  if (!jcgo_instanceOf(OBJT_java_util_List, MAXT_java_util_List, ~0,
+   (jObject)o))
+  {
+   return (jboolean)jfalse;
+  }
+  size= (JCGO_CALL_NZVFUNC(This)->size__(
+   (java_util_AbstractCollection)This));
+  if (size != (JCGO_CALL_NZVFUNC(((java_util_List)o))->size__(
+   ((java_util_List)o))))
+  {
+   return (jboolean)jfalse;
+  }
+  itr1= (JCGO_CALL_NZVFUNC(This)->iterator__(
+   This));
+  itr2= (JCGO_CALL_NZVFUNC(((java_util_List)o))->iterator__(
+   ((java_util_List)o)));
+  while (--size >= 0)
+  {
+   jObject jcgo_rcvrL1;
+   if (!(jcgo_rcvrL1= (jObject)(JCGO_CALL_VFUNC(itr1)->next__(
+    itr1)), java_util_AbstractCollection__equals__LoLo(
+    (java_lang_Object)jcgo_rcvrL1, (JCGO_CALL_VFUNC(itr2)->next__(
+    itr2)))))
+   {
+    return (jboolean)jfalse;
+   }
+  }
+  return (jboolean)jtrue;
+ }
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_util_AbstractList__hashCode__( java_util_AbstractList This )
+{
+ {
+  java_util_Iterator itr;
+  jint hashCode;
+  jint pos;
+  hashCode= (jint)1;
+  itr= (JCGO_CALL_NZVFUNC(This)->iterator__(
+   This));
+  pos= (JCGO_CALL_NZVFUNC(This)->size__(
+   (java_util_AbstractCollection)This));
+  while (--pos >= 0)
+  {
+   hashCode= hashCode * (jint)31 + (java_util_AbstractCollection__hashCode__Lo(
+    (JCGO_CALL_VFUNC(itr)->next__(
+    itr))));
+  }
+  return hashCode;
+ }
+}
+
+JCGO_NOSEP_INLINE java_util_Iterator CFASTCALL
+java_util_AbstractList__listIterator__( java_util_AbstractList This
+ )
+{
+ {
+  return (JCGO_CALL_NZVFUNC(This)->listIterator__I(
+   This, 0));
+ }
+}
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_util_AbstractList__remove__I( java_util_AbstractList This, jint
+ index )
+{
+ {
+  JCGO_THROW_EXC(java_lang_UnsupportedOperationException__new__());
+ }
+ return jnull;
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_util_AbstractList_methods=
+{
+ JCGO_CLASSREF_OF(java_util_AbstractList__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_util_AbstractList,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ (jObject (CFASTCALL*)(jObject))java_util_AbstractList__this__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_AbstractList_class_s
+ java_util_AbstractList__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_AbstractList_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstrcLs),
+  JCGO_CLASSREF_OF(java_util_AbstractCollection__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array4_AbstrcLs)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype2_GameMdl jcgo_array4_AbstrcLs=
+{
+ (jvtable)&jObjectArr_methods,
+ JCGO_MON_INIT
+ 1,
+ JCGO_CLASSREF_OF(java_lang_Class__class),
+ {
+  (jObject)JCGO_CLASSREF_OF(java_util_List__class)
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype94_GmCnnctn jcgo_array5_AbstrcLs=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 24,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)76/*'L'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)115/*'s'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)36/*'$'*/, (jbyte)(jchar)49/*'1'*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype24_Object jcgo_array6_AbstrcLs=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 7,
+ {
+  (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)100/*'d'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)120/*'x'*/, (jbyte)(jchar)58/*':'*/,
+   (jbyte)(jchar)32/*' '*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype24_Object jcgo_array7_AbstrcLs=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 7,
+ {
+  (jbyte)(jchar)44/*','*/, (jbyte)(jchar)32/*' '*/, (jbyte)(jchar)83/*'S'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)122/*'z'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)58/*':'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstrcLs
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array5_AbstrcLs),
+ 0, 22, (jint)0x6e291da0L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_AbstrcLs
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array6_AbstrcLs),
+ 0, 7, (jint)0xd70cdb58L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_AbstrcLs
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array7_AbstrcLs),
+ 0, 7, (jint)0x52f07345L
+};
+
+#ifdef CHKALL_java_util_AbstractList
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstrcLs.h

@@ -0,0 +1,105 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_util_AbstractList__add__ILo( java_util_AbstractList This, java_lang_Object
+ o, jint index );
+
+JCGO_NOSEP_FRWINL java_util_Iterator CFASTCALL
+java_util_AbstractList__iterator__( java_util_AbstractList This );
+
+JCGO_NOSEP_INLINE java_util_Iterator CFASTCALL
+java_util_AbstractList__listIterator__I( java_util_AbstractList This,
+ jint index );
+
+JCGO_NOSEP_STATIC java_util_AbstractList CFASTCALL
+java_util_AbstractList__this__( java_util_AbstractList This );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractList__add__Lo( java_util_AbstractList This, java_lang_Object
+ o );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractList__equals__Lo( java_util_AbstractList This, java_lang_Object
+ o );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_util_AbstractList__hashCode__( java_util_AbstractList This );
+
+JCGO_NOSEP_INLINE java_util_Iterator CFASTCALL
+java_util_AbstractList__listIterator__( java_util_AbstractList This
+ );
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_util_AbstractList__remove__I( java_util_AbstractList This, jint
+ index );
+
+struct java_util_AbstractList_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_AbstractList (CFASTCALL *jcgo_thisRtn)( java_util_AbstractList
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_util_AbstractList This, java_lang_Object
+  o );
+ jint (CFASTCALL *hashCode__)( java_util_AbstractList This );
+ java_lang_String (CFASTCALL *toString__)( java_util_AbstractCollection
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *isEmpty__)( java_util_AbstractCollection This
+  );
+ java_util_Iterator (CFASTCALL *iterator__)( java_util_AbstractList
+  This );
+ jint (CFASTCALL *size__)( java_util_AbstractCollection This );
+ jboolean (CFASTCALL *add__Lo)( java_util_AbstractList This, java_lang_Object
+  o );
+ jboolean (CFASTCALL *contains__Lo)( java_util_AbstractCollection This,
+  java_lang_Object o );
+ jboolean (CFASTCALL *containsAll__L07mt2)( java_util_AbstractCollection
+  This, java_util_Collection c );
+ java_lang_Object (CFASTCALL *get__I)( java_util_AbstractList This,
+  jint index );
+ void (CFASTCALL *add__ILo)( java_util_AbstractList This, java_lang_Object
+  o, jint index );
+ java_util_Iterator (CFASTCALL *listIterator__I)( java_util_AbstractList
+  This, jint index );
+ java_lang_Object (CFASTCALL *remove__I)( java_util_AbstractList This,
+  jint index );
+};
+
+struct java_util_AbstractList_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_util_AbstractList_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_AbstractList_class_s
+ java_util_AbstractList__class;
+
+struct java_util_AbstractList_s
+{
+ CONST struct java_util_AbstractList_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jint modCount;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype2_GameMdl jcgo_array4_AbstrcLs;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype94_GmCnnctn jcgo_array5_AbstrcLs;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype24_Object jcgo_array6_AbstrcLs;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype24_Object jcgo_array7_AbstrcLs;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstrcLs;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_AbstrcLs;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_AbstrcLs;
+
+#endif

jcgo_Out/AbstrcMp.c

@@ -0,0 +1,193 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_AbstractMap
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_util_AbstractMap CFASTCALL
+java_util_AbstractMap__this__( java_util_AbstractMap This )
+{
+ {
+  ;
+ }
+ return This;
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractMap__equals__Lo( java_util_AbstractMap This, java_lang_Object
+ o )
+{
+ {
+  jObject jcgo_rcvrL1;
+  return (jboolean)(o == (java_lang_Object)This || (jcgo_instanceOf(OBJT_java_util_Map,
+   MAXT_java_util_Map, ~0, (jObject)o) && (jcgo_rcvrL1= (jObject)(JCGO_CALL_NZVFUNC(This)->entrySet__(
+   This)), JCGO_CALL_VFUNC((java_util_Set)jcgo_rcvrL1)->equals__Lo(
+   (java_util_Set)jcgo_rcvrL1, (java_lang_Object)(JCGO_CALL_NZVFUNC(((java_util_Map)o))->entrySet__(
+   ((java_util_Map)o)))))));
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_AbstractMap__hashCode__( java_util_AbstractMap This )
+{
+ {
+  jObject jcgo_rcvrL1;
+  return (jcgo_rcvrL1= (jObject)(JCGO_CALL_NZVFUNC(This)->entrySet__(
+   This)), JCGO_CALL_VFUNC((java_util_Set)jcgo_rcvrL1)->hashCode__(
+   (java_util_Set)jcgo_rcvrL1));
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractMap__isEmpty__( java_util_AbstractMap This )
+{
+ {
+  return (jboolean)((JCGO_CALL_NZVFUNC(This)->size__(
+   This)) == 0);
+ }
+}
+
+JCGO_NOSEP_STATIC java_lang_String CFASTCALL
+java_util_AbstractMap__toString__( java_util_AbstractMap This )
+{
+ {
+  java_util_Iterator entries;
+  java_lang_StringBuilder r;
+  jObject jcgo_rcvrL1;
+  struct java_lang_StringBuilder_s jcgo_stackobj1;
+  entries= (jcgo_rcvrL1= (jObject)(JCGO_CALL_NZVFUNC(This)->entrySet__(
+   This)), JCGO_CALL_VFUNC((java_util_Set)jcgo_rcvrL1)->iterator__(
+   (java_util_Set)jcgo_rcvrL1));
+  r= (java_lang_StringBuilder__this__Ls(
+   JCGO_STACKOBJ_NEW(jcgo_stackobj1, java_lang_StringBuilder_methods),
+   JCGO_STRREF_OF(jcgo_string3_Hshtbl)));
+  {
+   jint pos;
+   pos= (JCGO_CALL_NZVFUNC(This)->size__(
+    This));
+   for (; pos > 0; pos--)
+   {
+    java_util_Map_Entry entry;
+    entry= (java_util_Map_Entry)JCGO_CAST_OBJECT(OBJT_java_util_Map_Entry,
+     MAXT_java_util_Map_Entry, ~0, (JCGO_CALL_VFUNC(entries)->next__(
+     entries)));
+    (java_lang_StringBuilder__append__Lo(
+     r, (JCGO_CALL_VFUNC(entry)->getKey__(
+     entry))));
+    (java_lang_StringBuilder__append__C(
+     r, (jchar)61/*'='*/));
+    (java_lang_StringBuilder__append__Lo(
+     r, (JCGO_CALL_NZVFUNC(entry)->getValue__(
+     entry))));
+    if (pos > (jint)1)
+    {
+     (java_lang_StringBuilder__append__Ls(
+      r, JCGO_STRREF_OF(jcgo_string4_Hshtbl)));
+    }
+   }
+  }
+  (java_lang_StringBuilder__append__C(
+   r, (jchar)125/*'}'*/));
+  return (java_lang_StringBuilder__toString__(
+   r));
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractMap__equals__LoLo( java_lang_Object o1, java_lang_Object
+ o2 )
+{
+ {
+  return (jboolean)(o1 == o2 || (o1 != jnull && (JCGO_CALL_NZVFUNC(o1)->equals__Lo(
+   o1, o2))));
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_AbstractMap__hashCode__Lo( java_lang_Object o )
+{
+ {
+  return o == jnull? 0 : (JCGO_CALL_NZVFUNC(o)->hashCode__(
+   o));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_util_AbstractMap_methods=
+{
+ JCGO_CLASSREF_OF(java_util_AbstractMap__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_util_AbstractMap,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ (jObject (CFASTCALL*)(jObject))java_util_AbstractMap__this__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_AbstractMap_class_s
+ java_util_AbstractMap__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_AbstractMap_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstrcMp),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array2_AbstrcMp)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype2_GameMdl jcgo_array2_AbstrcMp=
+{
+ (jvtable)&jObjectArr_methods,
+ JCGO_MON_INIT
+ 1,
+ JCGO_CLASSREF_OF(java_lang_Class__class),
+ {
+  (jObject)JCGO_CLASSREF_OF(java_util_Map__class)
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype88_GmCnnctn jcgo_array3_AbstrcMp=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 35,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)77/*'M'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)112/*'p'*/,
+   (jbyte)(jchar)36/*'$'*/, (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)99/*'c'*/,
+   (jbyte)(jchar)77/*'M'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)112/*'p'*/,
+   (jbyte)(jchar)69/*'E'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)121/*'y'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstrcMp
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array3_AbstrcMp),
+ 0, 21, (jint)0x6ee8901aL
+};
+
+#ifdef CHKALL_java_util_AbstractMap
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstrcMp.h

@@ -0,0 +1,77 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+#define java_util_AbstractMap__KEYS 0
+
+#define java_util_AbstractMap__VALUES (jint)1
+
+#define java_util_AbstractMap__ENTRIES (jint)2
+
+JCGO_NOSEP_STATIC java_util_AbstractMap CFASTCALL
+java_util_AbstractMap__this__( java_util_AbstractMap This );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractMap__equals__Lo( java_util_AbstractMap This, java_lang_Object
+ o );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_AbstractMap__hashCode__( java_util_AbstractMap This );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractMap__isEmpty__( java_util_AbstractMap This );
+
+JCGO_NOSEP_STATIC java_lang_String CFASTCALL
+java_util_AbstractMap__toString__( java_util_AbstractMap This );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_AbstractMap__equals__LoLo( java_lang_Object o1, java_lang_Object
+ o2 );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_AbstractMap__hashCode__Lo( java_lang_Object o );
+
+struct java_util_AbstractMap_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_AbstractMap (CFASTCALL *jcgo_thisRtn)( java_util_AbstractMap
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_util_AbstractMap This, java_lang_Object
+  o );
+ jint (CFASTCALL *hashCode__)( java_util_AbstractMap This );
+ java_lang_String (CFASTCALL *toString__)( java_util_AbstractMap This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_util_Set (CFASTCALL *entrySet__)( java_util_AbstractMap This
+  );
+ jboolean (CFASTCALL *isEmpty__)( java_util_AbstractMap This );
+ jint (CFASTCALL *size__)( java_util_AbstractMap This );
+};
+
+struct java_util_AbstractMap_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_util_AbstractMap_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_AbstractMap_class_s
+ java_util_AbstractMap__class;
+
+struct java_util_AbstractMap_s
+{
+ CONST struct java_util_AbstractMap_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype2_GameMdl jcgo_array2_AbstrcMp;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype88_GmCnnctn jcgo_array3_AbstrcMp;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstrcMp;
+
+#endif

jcgo_Out/AbstrcSt.c

@@ -0,0 +1,125 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_AbstractSet
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_util_AbstractSet CFASTCALL
+java_util_AbstractSet__this__( java_util_AbstractSet This )
+{
+ {
+  (java_util_AbstractCollection__this__((java_util_AbstractCollection)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractSet__equals__Lo( java_util_AbstractSet This, java_lang_Object
+ o )
+{
+ {
+  jint jcgo_rcvrI1;
+  return (jboolean)(o == (java_lang_Object)This || (jcgo_instanceOf(OBJT_java_util_Set,
+   MAXT_java_util_Set, ~0, (jObject)o) && (jcgo_rcvrI1= (JCGO_CALL_NZVFUNC(((java_util_Set)o))->size__(
+   ((java_util_Set)o))), jcgo_rcvrI1 == (JCGO_CALL_NZVFUNC(This)->size__(
+   (java_util_AbstractCollection)This))) && (JCGO_CALL_NZVFUNC(This)->containsAll__L07mt2(
+   (java_util_AbstractCollection)This, (java_util_Collection)o))));
+ }
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_util_AbstractSet__hashCode__( java_util_AbstractSet This )
+{
+ {
+  java_util_Iterator itr;
+  jint hash;
+  jint pos;
+  itr= (JCGO_CALL_NZVFUNC(This)->iterator__(
+   (java_util_AbstractCollection)This));
+  hash= 0;
+  pos= (JCGO_CALL_NZVFUNC(This)->size__(
+   (java_util_AbstractCollection)This));
+  while (--pos >= 0)
+  {
+   hash+= (java_util_AbstractCollection__hashCode__Lo(
+    (JCGO_CALL_VFUNC(itr)->next__(
+    itr))));
+  }
+  return hash;
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_util_AbstractSet_methods=
+{
+ JCGO_CLASSREF_OF(java_util_AbstractSet__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_util_AbstractSet,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ (jObject (CFASTCALL*)(jObject))java_util_AbstractSet__this__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_AbstractSet_class_s
+ java_util_AbstractSet__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_AbstractSet_methods),
+  JCGO_STRREF_OF(jcgo_string1_AbstrcSt),
+  JCGO_CLASSREF_OF(java_util_AbstractCollection__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array2_AbstrcSt)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype2_GameMdl jcgo_array2_AbstrcSt=
+{
+ (jvtable)&jObjectArr_methods,
+ JCGO_MON_INIT
+ 1,
+ JCGO_CLASSREF_OF(java_lang_Class__class),
+ {
+  (jObject)JCGO_CLASSREF_OF(java_util_Set__class)
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype80_GmCnnctn jcgo_array3_AbstrcSt=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 21,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)83/*'S'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)116/*'t'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstrcSt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array3_AbstrcSt),
+ 0, 21, (jint)0x6ee8a720L
+};
+
+#ifdef CHKALL_java_util_AbstractSet
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AbstrcSt.h

@@ -0,0 +1,65 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_util_AbstractSet CFASTCALL
+java_util_AbstractSet__this__( java_util_AbstractSet This );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractSet__equals__Lo( java_util_AbstractSet This, java_lang_Object
+ o );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_util_AbstractSet__hashCode__( java_util_AbstractSet This );
+
+struct java_util_AbstractSet_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_AbstractSet (CFASTCALL *jcgo_thisRtn)( java_util_AbstractSet
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_util_AbstractSet This, java_lang_Object
+  o );
+ jint (CFASTCALL *hashCode__)( java_util_AbstractSet This );
+ java_lang_String (CFASTCALL *toString__)( java_util_AbstractCollection
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *isEmpty__)( java_util_AbstractCollection This
+  );
+ java_util_Iterator (CFASTCALL *iterator__)( java_util_AbstractCollection
+  This );
+ jint (CFASTCALL *size__)( java_util_AbstractCollection This );
+ jboolean (CFASTCALL *add__Lo)( java_util_AbstractCollection This,
+  java_lang_Object o );
+ jboolean (CFASTCALL *contains__Lo)( java_util_AbstractCollection This,
+  java_lang_Object o );
+ jboolean (CFASTCALL *containsAll__L07mt2)( java_util_AbstractCollection
+  This, java_util_Collection c );
+};
+
+struct java_util_AbstractSet_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_util_AbstractSet_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_AbstractSet_class_s
+ java_util_AbstractSet__class;
+
+struct java_util_AbstractSet_s
+{
+ CONST struct java_util_AbstractSet_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype2_GameMdl jcgo_array2_AbstrcSt;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype80_GmCnnctn jcgo_array3_AbstrcSt;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AbstrcSt;
+
+#endif

jcgo_Out/AccssCnt.c

@@ -0,0 +1,104 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_security_AccessController
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_lang_Object CFASTCALL
+java_security_AccessController__doPrivileged__L21epy( java_security_PrivilegedAction
+ action )
+{
+ {
+  (java_security_VMAccessController__pushContext__L03o7q(
+   (java_lang_Object)jnull));
+  {
+   JCGO_TRY_BLOCK
+   {
+    {
+     java_lang_Object jcgo_retval= (JCGO_CALL_VFUNC(action)->run__(
+      action));
+#ifndef JCGO_SEHTRY
+     jcgo_tryLeave();
+     {
+      (java_security_VMAccessController__popContext__());
+     }
+#endif
+     return jcgo_retval;
+    }
+   }
+   JCGO_TRY_LEAVE
+   {
+    (java_security_VMAccessController__popContext__());
+   }
+   JCGO_TRY_FINALLYEND
+  }
+ }
+ return jnull;
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_security_AccessController_methods=
+{
+ JCGO_CLASSREF_OF(java_security_AccessController__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_security_AccessController,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_security_AccessController_class_s
+ java_security_AccessController__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_security_AccessController_methods),
+  JCGO_STRREF_OF(jcgo_string1_AccssCnt),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x11
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype77_GmCnnctn jcgo_array2_AccssCnt=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 30,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)115/*'s'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)67/*'C'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AccssCnt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_AccssCnt),
+ 0, 30, (jint)0x995ef462L
+};
+
+#ifdef CHKALL_java_security_AccessController
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AccssCnt.h

@@ -0,0 +1,46 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_lang_Object CFASTCALL
+java_security_AccessController__doPrivileged__L21epy( java_security_PrivilegedAction
+ action );
+
+struct java_security_AccessController_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_security_AccessController (CFASTCALL *jcgo_thisRtn)( java_security_AccessController
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct java_security_AccessController_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_security_AccessController_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_security_AccessController_class_s
+ java_security_AccessController__class;
+
+struct java_security_AccessController_s
+{
+ CONST struct java_security_AccessController_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype77_GmCnnctn jcgo_array2_AccssCnt;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AccssCnt;
+
+#endif

jcgo_Out/AccssbOb.c

@@ -0,0 +1,166 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_lang_reflect_AccessibleObject
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_lang_reflect_AccessibleObject__void( java_lang_reflect_AccessibleObject
+ This )
+{
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_lang_reflect_AccessibleObject__checkPermission__( void )
+{
+ {
+  java_lang_SecurityManager sm;
+  sm= (java_lang_System__getSecurityManager__());
+  if (sm != jnull)
+  {
+   struct java_lang_reflect_ReflectPermission_s jcgo_stackobj1;
+   (java_lang_SecurityManager__checkPermission__L37xkq(
+    sm, (java_security_Permission)(java_lang_reflect_ReflectPermission__this__Ls(
+    JCGO_STACKOBJ_NEW(jcgo_stackobj1, java_lang_reflect_ReflectPermission_methods),
+    JCGO_STRREF_OF(jcgo_string2_AccssbOb)))));
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_lang_reflect_AccessibleObject__secureSetAccessible__Z( java_lang_reflect_AccessibleObject
+ This, jboolean flag )
+{
+ {
+  if (flag && ((JCGO_METHODS_OF(This)->jcgo_typeid== OBJT_java_lang_reflect_Constructor) &&
+   (java_lang_reflect_Constructor__getDeclaringClass__(
+   ((java_lang_reflect_Constructor)This))) == JCGO_CLASSREF_OF(java_lang_Class__class)))
+  {
+   JCGO_THROW_EXC((java_lang_SecurityException__new__Ls(
+    JCGO_STRREF_OF(jcgo_string3_AccssbOb))));
+  }
+  JCGO_FIELD_NZACCESS(This, flag)= (jboolean)flag;
+ }
+}
+
+JCGO_NOSEP_STATIC java_lang_reflect_AccessibleObject CFASTCALL
+java_lang_reflect_AccessibleObject__this__( java_lang_reflect_AccessibleObject
+ This )
+{
+ {
+  ;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_lang_reflect_AccessibleObject__isAccessible__( java_lang_reflect_AccessibleObject
+ This )
+{
+ {
+  return (jboolean)JCGO_FIELD_NZACCESS(This, flag);
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_lang_reflect_AccessibleObject__setAccessible__Z( java_lang_reflect_AccessibleObject
+ This, jboolean flag )
+{
+ {
+  (java_lang_reflect_AccessibleObject__checkPermission__());
+  (java_lang_reflect_AccessibleObject__secureSetAccessible__Z(
+   This, (jboolean)flag));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct java_lang_reflect_AccessibleObject_methods_s
+ java_lang_reflect_AccessibleObject_methods=
+{
+ JCGO_CLASSREF_OF(java_lang_reflect_AccessibleObject__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_lang_reflect_AccessibleObject,
+ -(JCGO_OBJSIZE_T)sizeof(struct java_lang_reflect_AccessibleObject_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_lang_reflect_AccessibleObject__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Object__toString__,
+ java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_reflect_AccessibleObject_class_s
+ java_lang_reflect_AccessibleObject__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_lang_reflect_AccessibleObject_methods),
+  JCGO_STRREF_OF(jcgo_string1_AccssbOb),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype87_GmCnnctn jcgo_array4_AccssbOb=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 34,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)103/*'g'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)99/*'c'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)115/*'s'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)98/*'b'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)79/*'O'*/, (jbyte)(jchar)98/*'b'*/,
+   (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)99/*'c'*/,
+   (jbyte)(jchar)116/*'t'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AccssbOb
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array4_AccssbOb),
+ 0, 34, (jint)0x831952faL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_AccssbOb
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array480_VMSstmPr),
+ 0, 20, (jint)0x3e7d5644L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_AccssbOb
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array7_Class),
+ 0, 52, (jint)0xb7d30ecL
+};
+
+#ifdef CHKALL_java_lang_reflect_AccessibleObject
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AccssbOb.h

@@ -0,0 +1,71 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_lang_reflect_AccessibleObject__void( java_lang_reflect_AccessibleObject
+ This );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_lang_reflect_AccessibleObject__checkPermission__( void );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_lang_reflect_AccessibleObject__secureSetAccessible__Z( java_lang_reflect_AccessibleObject
+ This, jboolean flag );
+
+JCGO_NOSEP_STATIC java_lang_reflect_AccessibleObject CFASTCALL
+java_lang_reflect_AccessibleObject__this__( java_lang_reflect_AccessibleObject
+ This );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_lang_reflect_AccessibleObject__isAccessible__( java_lang_reflect_AccessibleObject
+ This );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_lang_reflect_AccessibleObject__setAccessible__Z( java_lang_reflect_AccessibleObject
+ This, jboolean flag );
+
+struct java_lang_reflect_AccessibleObject_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_lang_reflect_AccessibleObject (CFASTCALL *jcgo_thisRtn)( java_lang_reflect_AccessibleObject
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct java_lang_reflect_AccessibleObject_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_lang_reflect_AccessibleObject_methods_s
+ java_lang_reflect_AccessibleObject_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_reflect_AccessibleObject_class_s
+ java_lang_reflect_AccessibleObject__class;
+
+struct java_lang_reflect_AccessibleObject_s
+{
+ CONST struct java_lang_reflect_AccessibleObject_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ jboolean flag;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype87_GmCnnctn jcgo_array4_AccssbOb;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AccssbOb;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_AccssbOb;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_AccssbOb;
+
+#endif

jcgo_Out/AlrdCnEx.c

@@ -0,0 +1,101 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_channels_AlreadyConnectedException
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_nio_channels_AlreadyConnectedException CFASTCALL
+java_nio_channels_AlreadyConnectedException__this__( java_nio_channels_AlreadyConnectedException
+ This )
+{
+ {
+  (java_lang_IllegalStateException__this__((java_lang_IllegalStateException)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_nio_channels_AlreadyConnectedException CFASTCALL
+java_nio_channels_AlreadyConnectedException__new__( void )
+{
+ return java_nio_channels_AlreadyConnectedException__this__(
+  (java_nio_channels_AlreadyConnectedException)jcgo_newObject((jvtable)&java_nio_channels_AlreadyConnectedException_methods));
+}
+
+JCGO_NOSEP_DATA CONST struct java_nio_channels_AlreadyConnectedException_methods_s
+ java_nio_channels_AlreadyConnectedException_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_channels_AlreadyConnectedException__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_channels_AlreadyConnectedException,
+ (JCGO_OBJSIZE_T)sizeof(struct java_nio_channels_AlreadyConnectedException_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_nio_channels_AlreadyConnectedException__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Throwable__toString__,
+ java_lang_Object__finalize__,
+ java_lang_Throwable__getMessage__,
+ java_lang_Throwable__getCause__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_channels_AlreadyConnectedException_class_s
+ java_nio_channels_AlreadyConnectedException__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_channels_AlreadyConnectedException_methods),
+  JCGO_STRREF_OF(jcgo_string1_AlrdCnEx),
+  JCGO_CLASSREF_OF(java_lang_IllegalStateException__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype114_GmCnnctn jcgo_array2_AlrdCnEx=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 43,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)100/*'d'*/,
+   (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)67/*'C'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)100/*'d'*/, (jbyte)(jchar)69/*'E'*/, (jbyte)(jchar)120/*'x'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)112/*'p'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AlrdCnEx
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_AlrdCnEx),
+ 0, 43, (jint)0x46af2066L
+};
+
+#ifdef CHKALL_java_nio_channels_AlreadyConnectedException
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AlrdCnEx.h

@@ -0,0 +1,58 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_nio_channels_AlreadyConnectedException CFASTCALL
+java_nio_channels_AlreadyConnectedException__this__( java_nio_channels_AlreadyConnectedException
+ This );
+JCGO_NOSEP_INLINE java_nio_channels_AlreadyConnectedException CFASTCALL
+java_nio_channels_AlreadyConnectedException__new__( void );
+
+struct java_nio_channels_AlreadyConnectedException_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_channels_AlreadyConnectedException (CFASTCALL *jcgo_thisRtn)(
+  java_nio_channels_AlreadyConnectedException This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Throwable This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getMessage__)( java_lang_Throwable This
+  );
+ java_lang_Throwable (CFASTCALL *getCause__)( java_lang_Throwable This
+  );
+};
+
+struct java_nio_channels_AlreadyConnectedException_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_nio_channels_AlreadyConnectedException_methods_s
+ java_nio_channels_AlreadyConnectedException_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_channels_AlreadyConnectedException_class_s
+ java_nio_channels_AlreadyConnectedException__class;
+
+struct java_nio_channels_AlreadyConnectedException_s
+{
+ CONST struct java_nio_channels_AlreadyConnectedException_methods_s
+  *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String detailMessage;
+ java_lang_Throwable cause;
+ jObjectArr stackTrace;
+ java_lang_VMThrowable vmState;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype114_GmCnnctn jcgo_array2_AlrdCnEx;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AlrdCnEx;
+
+#endif

jcgo_Out/AppClsLd.c

@@ -0,0 +1,89 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_lang_VMClassLoader
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE java_lang_VMClassLoader_AppClassLoader CFASTCALL
+java_lang_VMClassLoader_AppClassLoader__this__( java_lang_VMClassLoader_AppClassLoader
+ This )
+{
+ {
+  (java_lang_ClassLoader__this__L09rb1((java_lang_ClassLoader)This,
+   (java_lang_ClassLoader)jnull));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_lang_VMClassLoader_AppClassLoader CFASTCALL
+java_lang_VMClassLoader_AppClassLoader__new__( void )
+{
+ return java_lang_VMClassLoader_AppClassLoader__this__(
+  (java_lang_VMClassLoader_AppClassLoader)jcgo_newObject((jvtable)&java_lang_VMClassLoader_AppClassLoader_methods));
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_lang_VMClassLoader_AppClassLoader__toString__( java_lang_VMClassLoader_AppClassLoader
+ This )
+{
+ {
+  jObject jcgo_rcvrL1;
+  return (jcgo_rcvrL1= (jObject)(java_lang_Object__getClass__(
+   (java_lang_Object)This)), JCGO_CALL_FINALF((java_lang_Class)jcgo_rcvrL1)
+   java_lang_Class__getName__(
+   (java_lang_Class)jcgo_rcvrL1));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct java_lang_VMClassLoader_AppClassLoader_methods_s
+ java_lang_VMClassLoader_AppClassLoader_methods=
+{
+ JCGO_CLASSREF_OF(java_lang_VMClassLoader_AppClassLoader__class),
+ JCGO_GCJDESCR_INIT(java_lang_VMClassLoader_AppClassLoader_s, parent)
+ OBJT_java_lang_VMClassLoader_AppClassLoader,
+ (JCGO_OBJSIZE_T)sizeof(struct java_lang_VMClassLoader_AppClassLoader_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_lang_VMClassLoader_AppClassLoader__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_VMClassLoader_AppClassLoader__toString__,
+ java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_VMClassLoader_AppClassLoader_class_s
+ java_lang_VMClassLoader_AppClassLoader__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_lang_VMClassLoader_AppClassLoader_methods),
+  JCGO_STRREF_OF(jcgo_string1_AppClsLd),
+  JCGO_CLASSREF_OF(java_lang_ClassLoader__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1a
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AppClsLd
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array4_VMClssLd),
+ 0, 38, (jint)0x505b7c4eL
+};
+
+#ifdef CHKALL_java_lang_VMClassLoader
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AppClsLd.h

@@ -0,0 +1,54 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE java_lang_VMClassLoader_AppClassLoader CFASTCALL
+java_lang_VMClassLoader_AppClassLoader__this__( java_lang_VMClassLoader_AppClassLoader
+ This );
+JCGO_NOSEP_INLINE java_lang_VMClassLoader_AppClassLoader CFASTCALL
+java_lang_VMClassLoader_AppClassLoader__new__( void );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_lang_VMClassLoader_AppClassLoader__toString__( java_lang_VMClassLoader_AppClassLoader
+ This );
+
+struct java_lang_VMClassLoader_AppClassLoader_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_lang_VMClassLoader_AppClassLoader (CFASTCALL *jcgo_thisRtn)(
+  java_lang_VMClassLoader_AppClassLoader This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_VMClassLoader_AppClassLoader
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct java_lang_VMClassLoader_AppClassLoader_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_lang_VMClassLoader_AppClassLoader_methods_s
+ java_lang_VMClassLoader_AppClassLoader_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_VMClassLoader_AppClassLoader_class_s
+ java_lang_VMClassLoader_AppClassLoader__class;
+
+struct java_lang_VMClassLoader_AppClassLoader_s
+{
+ CONST struct java_lang_VMClassLoader_AppClassLoader_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_ClassLoader parent;
+ jboolean initialized;
+};
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AppClsLd;
+
+#endif

jcgo_Out/ArInOtOf.c

@@ -0,0 +1,100 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_lang_ArrayIndexOutOfBoundsException
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_lang_ArrayIndexOutOfBoundsException CFASTCALL
+java_lang_ArrayIndexOutOfBoundsException__this__( java_lang_ArrayIndexOutOfBoundsException
+ This )
+{
+ {
+  (java_lang_IndexOutOfBoundsException__this__((java_lang_IndexOutOfBoundsException)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_lang_ArrayIndexOutOfBoundsException CFASTCALL
+java_lang_ArrayIndexOutOfBoundsException__new__( void )
+{
+ return java_lang_ArrayIndexOutOfBoundsException__this__(
+  (java_lang_ArrayIndexOutOfBoundsException)jcgo_newObject((jvtable)&java_lang_ArrayIndexOutOfBoundsException_methods));
+}
+
+JCGO_NOSEP_DATA CONST struct java_lang_ArrayIndexOutOfBoundsException_methods_s
+ java_lang_ArrayIndexOutOfBoundsException_methods=
+{
+ JCGO_CLASSREF_OF(java_lang_ArrayIndexOutOfBoundsException__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_lang_ArrayIndexOutOfBoundsException,
+ (JCGO_OBJSIZE_T)sizeof(struct java_lang_ArrayIndexOutOfBoundsException_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_lang_ArrayIndexOutOfBoundsException__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Throwable__toString__,
+ java_lang_Object__finalize__,
+ java_lang_Throwable__getMessage__,
+ java_lang_Throwable__getCause__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_ArrayIndexOutOfBoundsException_class_s
+ java_lang_ArrayIndexOutOfBoundsException__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_lang_ArrayIndexOutOfBoundsException_methods),
+  JCGO_STRREF_OF(jcgo_string1_ArInOtOf),
+  JCGO_CLASSREF_OF(java_lang_IndexOutOfBoundsException__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype120_GmCnnctn jcgo_array2_ArInOtOf=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 40,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)103/*'g'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)121/*'y'*/,
+   (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)100/*'d'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)120/*'x'*/, (jbyte)(jchar)79/*'O'*/,
+   (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)79/*'O'*/,
+   (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)100/*'d'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)69/*'E'*/, (jbyte)(jchar)120/*'x'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)112/*'p'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ArInOtOf
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_ArInOtOf),
+ 0, 40, (jint)0x60e95a82L
+};
+
+#ifdef CHKALL_java_lang_ArrayIndexOutOfBoundsException
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/ArInOtOf.h

@@ -0,0 +1,58 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_lang_ArrayIndexOutOfBoundsException CFASTCALL
+java_lang_ArrayIndexOutOfBoundsException__this__( java_lang_ArrayIndexOutOfBoundsException
+ This );
+JCGO_NOSEP_INLINE java_lang_ArrayIndexOutOfBoundsException CFASTCALL
+java_lang_ArrayIndexOutOfBoundsException__new__( void );
+
+struct java_lang_ArrayIndexOutOfBoundsException_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_lang_ArrayIndexOutOfBoundsException (CFASTCALL *jcgo_thisRtn)(
+  java_lang_ArrayIndexOutOfBoundsException This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Throwable This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getMessage__)( java_lang_Throwable This
+  );
+ java_lang_Throwable (CFASTCALL *getCause__)( java_lang_Throwable This
+  );
+};
+
+struct java_lang_ArrayIndexOutOfBoundsException_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_lang_ArrayIndexOutOfBoundsException_methods_s
+ java_lang_ArrayIndexOutOfBoundsException_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_ArrayIndexOutOfBoundsException_class_s
+ java_lang_ArrayIndexOutOfBoundsException__class;
+
+struct java_lang_ArrayIndexOutOfBoundsException_s
+{
+ CONST struct java_lang_ArrayIndexOutOfBoundsException_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String detailMessage;
+ java_lang_Throwable cause;
+ jObjectArr stackTrace;
+ java_lang_VMThrowable vmState;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype120_GmCnnctn jcgo_array2_ArInOtOf;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ArInOtOf;
+
+#endif

jcgo_Out/ArrLstD3.c

@@ -0,0 +1,140 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_Arrays
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE java_util_Arrays_ArrayList CFASTCALL
+java_util_Arrays_ArrayList__this__LoA( java_util_Arrays_ArrayList
+ This, jObjectArr a )
+{
+ {
+  (java_util_AbstractList__this__((java_util_AbstractList)This));
+  if (a == jnull)
+  {
+   JCGO_THROW_EXC(java_lang_NullPointerException__new__());
+  }
+  JCGO_FIELD_NZACCESS(This, a)= a;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_util_Arrays_ArrayList CFASTCALL
+java_util_Arrays_ArrayList__new__LoA( jObjectArr a )
+{
+ return java_util_Arrays_ArrayList__this__LoA(
+  (java_util_Arrays_ArrayList)jcgo_newObject((jvtable)&java_util_Arrays_ArrayList_methods),
+  a);
+}
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_util_Arrays_ArrayList__get__I( java_util_Arrays_ArrayList This,
+ jint index )
+{
+ {
+  return ((java_lang_Object)JCGO_ARRAY_LACCESS(JCGO_FIELD_NZACCESS(This,
+   a), index));
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_Arrays_ArrayList__size__( java_util_Arrays_ArrayList This
+ )
+{
+ {
+  return JCGO_ARRAY_LENGTH(JCGO_FIELD_NZACCESS(This, a));
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_Arrays_ArrayList__contains__Lo( java_util_Arrays_ArrayList
+ This, java_lang_Object o )
+{
+ {
+  return (jboolean)((java_util_Arrays_ArrayList__lastIndexOf__Lo(
+   This, o)) >= 0);
+ }
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_util_Arrays_ArrayList__lastIndexOf__Lo( java_util_Arrays_ArrayList
+ This, java_lang_Object o )
+{
+ {
+  jint i;
+  i= JCGO_ARRAY_LENGTH(JCGO_FIELD_NZACCESS(This, a));
+  while (--i >= 0)
+  {
+   if ((java_util_AbstractCollection__equals__LoLo(
+    o, ((java_lang_Object)JCGO_ARRAY_NZLACCESS(JCGO_FIELD_NZACCESS(This,
+    a), i)))))
+   {
+    return i;
+   }
+  }
+  return (-(jint)1);
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct java_util_Arrays_ArrayList_methods_s
+ java_util_Arrays_ArrayList_methods=
+{
+ JCGO_CLASSREF_OF(java_util_Arrays_ArrayList__class),
+ JCGO_GCJDESCR_INIT(java_util_Arrays_ArrayList_s, a)
+ OBJT_java_util_Arrays_ArrayList,
+ (JCGO_OBJSIZE_T)sizeof(struct java_util_Arrays_ArrayList_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_util_AbstractList__equals__Lo,
+ java_util_AbstractList__hashCode__,
+ java_util_AbstractCollection__toString__,
+ java_lang_Object__finalize__,
+ java_util_AbstractCollection__isEmpty__,
+ java_util_AbstractList__iterator__,
+ java_util_Arrays_ArrayList__size__,
+ java_util_AbstractList__add__Lo,
+ java_util_Arrays_ArrayList__contains__Lo,
+ java_util_AbstractCollection__containsAll__L07mt2,
+ java_util_Arrays_ArrayList__get__I,
+ java_util_AbstractList__add__ILo,
+ java_util_AbstractList__listIterator__I,
+ java_util_AbstractList__remove__I
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_Arrays_ArrayList_class_s
+ java_util_Arrays_ArrayList__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_Arrays_ArrayList_methods),
+  JCGO_STRREF_OF(jcgo_string1_ArrLstD3),
+  JCGO_CLASSREF_OF(java_util_AbstractList__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1a
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ArrLstD3
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_Arrays),
+ 0, 26, (jint)0xab3ed4dL
+};
+
+#ifdef CHKALL_java_util_Arrays
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/ArrLstD3.h

@@ -0,0 +1,85 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE java_util_Arrays_ArrayList CFASTCALL
+java_util_Arrays_ArrayList__this__LoA( java_util_Arrays_ArrayList
+ This, jObjectArr a );
+JCGO_NOSEP_INLINE java_util_Arrays_ArrayList CFASTCALL
+java_util_Arrays_ArrayList__new__LoA( jObjectArr a );
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_util_Arrays_ArrayList__get__I( java_util_Arrays_ArrayList This,
+ jint index );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_Arrays_ArrayList__size__( java_util_Arrays_ArrayList This
+ );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_util_Arrays_ArrayList__contains__Lo( java_util_Arrays_ArrayList
+ This, java_lang_Object o );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_util_Arrays_ArrayList__lastIndexOf__Lo( java_util_Arrays_ArrayList
+ This, java_lang_Object o );
+
+struct java_util_Arrays_ArrayList_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_Arrays_ArrayList (CFASTCALL *jcgo_thisRtn)( java_util_Arrays_ArrayList
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_util_AbstractList This, java_lang_Object
+  o );
+ jint (CFASTCALL *hashCode__)( java_util_AbstractList This );
+ java_lang_String (CFASTCALL *toString__)( java_util_AbstractCollection
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *isEmpty__)( java_util_AbstractCollection This
+  );
+ java_util_Iterator (CFASTCALL *iterator__)( java_util_AbstractList
+  This );
+ jint (CFASTCALL *size__)( java_util_Arrays_ArrayList This );
+ jboolean (CFASTCALL *add__Lo)( java_util_AbstractList This, java_lang_Object
+  o );
+ jboolean (CFASTCALL *contains__Lo)( java_util_Arrays_ArrayList This,
+  java_lang_Object o );
+ jboolean (CFASTCALL *containsAll__L07mt2)( java_util_AbstractCollection
+  This, java_util_Collection c );
+ java_lang_Object (CFASTCALL *get__I)( java_util_Arrays_ArrayList This,
+  jint index );
+ void (CFASTCALL *add__ILo)( java_util_AbstractList This, java_lang_Object
+  o, jint index );
+ java_util_Iterator (CFASTCALL *listIterator__I)( java_util_AbstractList
+  This, jint index );
+ java_lang_Object (CFASTCALL *remove__I)( java_util_AbstractList This,
+  jint index );
+};
+
+struct java_util_Arrays_ArrayList_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_util_Arrays_ArrayList_methods_s
+ java_util_Arrays_ArrayList_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_Arrays_ArrayList_class_s
+ java_util_Arrays_ArrayList__class;
+
+struct java_util_Arrays_ArrayList_s
+{
+ CONST struct java_util_Arrays_ArrayList_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ jint modCount;
+ jObjectArr a;
+};
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ArrLstD3;
+
+#endif

jcgo_Out/ArrStrEx.c

@@ -0,0 +1,96 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_lang_ArrayStoreException
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_lang_ArrayStoreException CFASTCALL
+java_lang_ArrayStoreException__this__( java_lang_ArrayStoreException
+ This )
+{
+ {
+  (java_lang_RuntimeException__this__((java_lang_RuntimeException)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_lang_ArrayStoreException CFASTCALL
+java_lang_ArrayStoreException__new__( void )
+{
+ return java_lang_ArrayStoreException__this__(
+  (java_lang_ArrayStoreException)jcgo_newObject((jvtable)&java_lang_ArrayStoreException_methods));
+}
+
+JCGO_NOSEP_DATA CONST struct java_lang_ArrayStoreException_methods_s
+ java_lang_ArrayStoreException_methods=
+{
+ JCGO_CLASSREF_OF(java_lang_ArrayStoreException__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_lang_ArrayStoreException,
+ (JCGO_OBJSIZE_T)sizeof(struct java_lang_ArrayStoreException_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_lang_ArrayStoreException__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Throwable__toString__,
+ java_lang_Object__finalize__,
+ java_lang_Throwable__getMessage__,
+ java_lang_Throwable__getCause__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_ArrayStoreException_class_s
+ java_lang_ArrayStoreException__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_lang_ArrayStoreException_methods),
+  JCGO_STRREF_OF(jcgo_string1_ArrStrEx),
+  JCGO_CLASSREF_OF(java_lang_RuntimeException__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype86_GmCnnctn jcgo_array2_ArrStrEx=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 29,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)103/*'g'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)121/*'y'*/,
+   (jbyte)(jchar)83/*'S'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)69/*'E'*/,
+   (jbyte)(jchar)120/*'x'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ArrStrEx
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_ArrStrEx),
+ 0, 29, (jint)0xe5ef2553L
+};
+
+#ifdef CHKALL_java_lang_ArrayStoreException
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/ArrStrEx.h

@@ -0,0 +1,58 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_lang_ArrayStoreException CFASTCALL
+java_lang_ArrayStoreException__this__( java_lang_ArrayStoreException
+ This );
+JCGO_NOSEP_INLINE java_lang_ArrayStoreException CFASTCALL
+java_lang_ArrayStoreException__new__( void );
+
+struct java_lang_ArrayStoreException_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_lang_ArrayStoreException (CFASTCALL *jcgo_thisRtn)( java_lang_ArrayStoreException
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Throwable This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getMessage__)( java_lang_Throwable This
+  );
+ java_lang_Throwable (CFASTCALL *getCause__)( java_lang_Throwable This
+  );
+};
+
+struct java_lang_ArrayStoreException_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_lang_ArrayStoreException_methods_s
+ java_lang_ArrayStoreException_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_ArrayStoreException_class_s
+ java_lang_ArrayStoreException__class;
+
+struct java_lang_ArrayStoreException_s
+{
+ CONST struct java_lang_ArrayStoreException_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String detailMessage;
+ java_lang_Throwable cause;
+ jObjectArr stackTrace;
+ java_lang_VMThrowable vmState;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype86_GmCnnctn jcgo_array2_ArrStrEx;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ArrStrEx;
+
+#endif

jcgo_Out/Arrays.c

@@ -0,0 +1,80 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_Arrays
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_FRWINL java_util_List CFASTCALL
+java_util_Arrays__asList__LoA( jObjectArr a )
+{
+ {
+  return (java_util_List)(java_util_Arrays_ArrayList__new__LoA(
+   a));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_util_Arrays_methods=
+{
+ JCGO_CLASSREF_OF(java_util_Arrays__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_util_Arrays,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_Arrays_class_s java_util_Arrays__class
+ JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_Arrays_methods),
+  JCGO_STRREF_OF(jcgo_string1_Arrays),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype27_Object jcgo_array2_Arrays=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 26,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)121/*'y'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)36/*'$'*/, (jbyte)(jchar)65/*'A'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)76/*'L'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)116/*'t'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_Arrays
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_Arrays),
+ 0, 16, (jint)0xa7f812faL
+};
+
+#ifdef CHKALL_java_util_Arrays
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/Arrays.h

@@ -0,0 +1,43 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_FRWINL java_util_List CFASTCALL
+java_util_Arrays__asList__LoA( jObjectArr a );
+
+struct java_util_Arrays_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_Arrays (CFASTCALL *jcgo_thisRtn)( java_util_Arrays This
+  );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct java_util_Arrays_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_util_Arrays_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_Arrays_class_s java_util_Arrays__class;
+
+struct java_util_Arrays_s
+{
+ CONST struct java_util_Arrays_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype27_Object jcgo_array2_Arrays;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_Arrays;
+
+#endif

jcgo_Out/ArthmtEx.c

@@ -0,0 +1,108 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_lang_ArithmeticException
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_lang_ArithmeticException CFASTCALL
+java_lang_ArithmeticException__this__( java_lang_ArithmeticException
+ This )
+{
+ {
+  (java_lang_RuntimeException__this__((java_lang_RuntimeException)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_lang_ArithmeticException CFASTCALL
+java_lang_ArithmeticException__this__Ls( java_lang_ArithmeticException
+ This, java_lang_String s )
+{
+ {
+  (java_lang_RuntimeException__this__Ls((java_lang_RuntimeException)This,
+   s));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_lang_ArithmeticException CFASTCALL
+java_lang_ArithmeticException__new__Ls( java_lang_String s )
+{
+ return java_lang_ArithmeticException__this__Ls(
+  (java_lang_ArithmeticException)jcgo_newObject((jvtable)&java_lang_ArithmeticException_methods),
+  s);
+}
+
+JCGO_NOSEP_DATA CONST struct java_lang_ArithmeticException_methods_s
+ java_lang_ArithmeticException_methods=
+{
+ JCGO_CLASSREF_OF(java_lang_ArithmeticException__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_lang_ArithmeticException,
+ (JCGO_OBJSIZE_T)sizeof(struct java_lang_ArithmeticException_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_lang_ArithmeticException__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Throwable__toString__,
+ java_lang_Object__finalize__,
+ java_lang_Throwable__getMessage__,
+ java_lang_Throwable__getCause__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_ArithmeticException_class_s
+ java_lang_ArithmeticException__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_lang_ArithmeticException_methods),
+  JCGO_STRREF_OF(jcgo_string1_ArthmtEx),
+  JCGO_CLASSREF_OF(java_lang_RuntimeException__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype86_GmCnnctn jcgo_array2_ArthmtEx=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 29,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)103/*'g'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)109/*'m'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)69/*'E'*/,
+   (jbyte)(jchar)120/*'x'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ArthmtEx
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_ArthmtEx),
+ 0, 29, (jint)0xceebe8f1L
+};
+
+#ifdef CHKALL_java_lang_ArithmeticException
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/ArthmtEx.h

@@ -0,0 +1,62 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_lang_ArithmeticException CFASTCALL
+java_lang_ArithmeticException__this__( java_lang_ArithmeticException
+ This );
+
+JCGO_NOSEP_INLINE java_lang_ArithmeticException CFASTCALL
+java_lang_ArithmeticException__this__Ls( java_lang_ArithmeticException
+ This, java_lang_String s );
+JCGO_NOSEP_INLINE java_lang_ArithmeticException CFASTCALL
+java_lang_ArithmeticException__new__Ls( java_lang_String s );
+
+struct java_lang_ArithmeticException_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_lang_ArithmeticException (CFASTCALL *jcgo_thisRtn)( java_lang_ArithmeticException
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Throwable This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getMessage__)( java_lang_Throwable This
+  );
+ java_lang_Throwable (CFASTCALL *getCause__)( java_lang_Throwable This
+  );
+};
+
+struct java_lang_ArithmeticException_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_lang_ArithmeticException_methods_s
+ java_lang_ArithmeticException_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_ArithmeticException_class_s
+ java_lang_ArithmeticException__class;
+
+struct java_lang_ArithmeticException_s
+{
+ CONST struct java_lang_ArithmeticException_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String detailMessage;
+ java_lang_Throwable cause;
+ jObjectArr stackTrace;
+ java_lang_VMThrowable vmState;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype86_GmCnnctn jcgo_array2_ArthmtEx;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ArthmtEx;
+
+#endif

jcgo_Out/Ascii.c

@@ -0,0 +1,154 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_gnu_java_nio_charset_US_1ASCII
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE gnu_java_nio_charset_US_ASCII CFASTCALL
+gnu_java_nio_charset_US_ASCII__this__( gnu_java_nio_charset_US_ASCII
+ This )
+{
+ {
+  (java_nio_charset_Charset__this__LsLsA((java_nio_charset_Charset)This,
+   JCGO_STRREF_OF(jcgo_string359_VMSstmPr), (jObjectArr)jcgo_arrayClone((jObject)JCGO_OBJREF_OF(jcgo_array5_Ascii))));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE gnu_java_nio_charset_US_ASCII CFASTCALL
+gnu_java_nio_charset_US_ASCII__new__( void )
+{
+ return gnu_java_nio_charset_US_ASCII__this__(
+  (gnu_java_nio_charset_US_ASCII)jcgo_newObject((jvtable)&gnu_java_nio_charset_US_ASCII_methods));
+}
+
+JCGO_NOSEP_INLINE java_nio_charset_CharsetDecoder CFASTCALL
+gnu_java_nio_charset_US_ASCII__newDecoder__( gnu_java_nio_charset_US_ASCII
+ This )
+{
+ {
+  return (java_nio_charset_CharsetDecoder)(gnu_java_nio_charset_US_ASCII_Decoder__new__L7qsf6(
+   (java_nio_charset_Charset)This));
+ }
+}
+
+JCGO_NOSEP_INLINE java_nio_charset_CharsetEncoder CFASTCALL
+gnu_java_nio_charset_US_ASCII__newEncoder__( gnu_java_nio_charset_US_ASCII
+ This )
+{
+ {
+  return (java_nio_charset_CharsetEncoder)(gnu_java_nio_charset_US_ASCII_Encoder__new__L7qsf6(
+   (java_nio_charset_Charset)This));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct gnu_java_nio_charset_US_ASCII_methods_s
+ gnu_java_nio_charset_US_ASCII_methods=
+{
+ JCGO_CLASSREF_OF(gnu_java_nio_charset_US_ASCII__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_gnu_java_nio_charset_US_ASCII,
+ (JCGO_OBJSIZE_T)sizeof(struct gnu_java_nio_charset_US_ASCII_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ gnu_java_nio_charset_US_ASCII__this__,
+ java_nio_charset_Charset__equals__Lo,
+ java_nio_charset_Charset__hashCode__,
+ java_nio_charset_Charset__toString__,
+ java_lang_Object__finalize__,
+ gnu_java_nio_charset_US_ASCII__newDecoder__,
+ gnu_java_nio_charset_US_ASCII__newEncoder__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct gnu_java_nio_charset_US_ASCII_class_s
+ gnu_java_nio_charset_US_ASCII__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&gnu_java_nio_charset_US_ASCII_methods),
+  JCGO_STRREF_OF(jcgo_string1_Ascii),
+  JCGO_CLASSREF_OF(java_nio_charset_Charset__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x10
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype5_Ascii jcgo_array5_Ascii=
+{
+ (jvtable)&jObjectArr_methods,
+ JCGO_MON_INIT
+ 15,
+ JCGO_CLASSREF_OF(java_lang_String__class),
+ {
+  (jObject)JCGO_STRREF_OF(jcgo_string356_VMSstmPr), (jObject)JCGO_STRREF_OF(jcgo_string362_VMSstmPr),
+   (jObject)JCGO_STRREF_OF(jcgo_string353_VMSstmPr), (jObject)JCGO_STRREF_OF(jcgo_string363_VMSstmPr),
+   (jObject)JCGO_STRREF_OF(jcgo_string364_VMSstmPr), (jObject)JCGO_STRREF_OF(jcgo_string363_VMSstmPr),
+   (jObject)JCGO_STRREF_OF(jcgo_string358_VMSstmPr), (jObject)JCGO_STRREF_OF(jcgo_string2_Ascii),
+   (jObject)JCGO_STRREF_OF(jcgo_string3_Ascii), (jObject)JCGO_STRREF_OF(jcgo_string355_VMSstmPr),
+   (jObject)JCGO_STRREF_OF(jcgo_string361_VMSstmPr), (jObject)JCGO_STRREF_OF(jcgo_string357_VMSstmPr),
+   (jObject)JCGO_STRREF_OF(jcgo_string354_VMSstmPr), (jObject)JCGO_STRREF_OF(jcgo_string383_VMSstmPr),
+   (jObject)JCGO_STRREF_OF(jcgo_string4_Ascii)
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype30_Object jcgo_array6_Ascii=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 5,
+ {
+  (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)51/*'3'*/,
+   (jbyte)(jchar)54/*'6'*/, (jbyte)(jchar)55/*'7'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_Ascii
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array672_VMSstmPr),
+ 0, 29, (jint)0x3ea7d018L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_Ascii
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array681_VMSstmPr),
+ 0, 6, (jint)0x80579b60L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_Ascii
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array6_Ascii),
+ 0, 5, (jint)0x5a6c6a7L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string4_Ascii
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array686_VMSstmPr),
+ 0, 13, (jint)0x141faf6eL
+};
+
+#ifdef CHKALL_gnu_java_nio_charset_US_1ASCII
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/Ascii.h

@@ -0,0 +1,72 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE gnu_java_nio_charset_US_ASCII CFASTCALL
+gnu_java_nio_charset_US_ASCII__this__( gnu_java_nio_charset_US_ASCII
+ This );
+JCGO_NOSEP_INLINE gnu_java_nio_charset_US_ASCII CFASTCALL
+gnu_java_nio_charset_US_ASCII__new__( void );
+
+JCGO_NOSEP_INLINE java_nio_charset_CharsetDecoder CFASTCALL
+gnu_java_nio_charset_US_ASCII__newDecoder__( gnu_java_nio_charset_US_ASCII
+ This );
+
+JCGO_NOSEP_INLINE java_nio_charset_CharsetEncoder CFASTCALL
+gnu_java_nio_charset_US_ASCII__newEncoder__( gnu_java_nio_charset_US_ASCII
+ This );
+
+struct gnu_java_nio_charset_US_ASCII_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ gnu_java_nio_charset_US_ASCII (CFASTCALL *jcgo_thisRtn)( gnu_java_nio_charset_US_ASCII
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_nio_charset_Charset This, java_lang_Object
+  ob );
+ jint (CFASTCALL *hashCode__)( java_nio_charset_Charset This );
+ java_lang_String (CFASTCALL *toString__)( java_nio_charset_Charset
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_nio_charset_CharsetDecoder (CFASTCALL *newDecoder__)( gnu_java_nio_charset_US_ASCII
+  This );
+ java_nio_charset_CharsetEncoder (CFASTCALL *newEncoder__)( gnu_java_nio_charset_US_ASCII
+  This );
+};
+
+struct gnu_java_nio_charset_US_ASCII_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct gnu_java_nio_charset_US_ASCII_methods_s
+ gnu_java_nio_charset_US_ASCII_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct gnu_java_nio_charset_US_ASCII_class_s
+ gnu_java_nio_charset_US_ASCII__class;
+
+struct gnu_java_nio_charset_US_ASCII_s
+{
+ CONST struct gnu_java_nio_charset_US_ASCII_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String canonicalName;
+ jObjectArr aliases;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype5_Ascii jcgo_array5_Ascii;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype30_Object jcgo_array6_Ascii;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_Ascii;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_Ascii;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_Ascii;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string4_Ascii;
+
+#endif

jcgo_Out/AsncClEx.c

@@ -0,0 +1,101 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_channels_AsynchronousCloseException
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_nio_channels_AsynchronousCloseException CFASTCALL
+java_nio_channels_AsynchronousCloseException__this__( java_nio_channels_AsynchronousCloseException
+ This )
+{
+ {
+  (java_nio_channels_ClosedChannelException__this__((java_nio_channels_ClosedChannelException)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_nio_channels_AsynchronousCloseException CFASTCALL
+java_nio_channels_AsynchronousCloseException__new__( void )
+{
+ return java_nio_channels_AsynchronousCloseException__this__(
+  (java_nio_channels_AsynchronousCloseException)jcgo_newObject((jvtable)&java_nio_channels_AsynchronousCloseException_methods));
+}
+
+JCGO_NOSEP_DATA CONST struct java_nio_channels_AsynchronousCloseException_methods_s
+ java_nio_channels_AsynchronousCloseException_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_channels_AsynchronousCloseException__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_channels_AsynchronousCloseException,
+ (JCGO_OBJSIZE_T)sizeof(struct java_nio_channels_AsynchronousCloseException_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_nio_channels_AsynchronousCloseException__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Throwable__toString__,
+ java_lang_Object__finalize__,
+ java_lang_Throwable__getMessage__,
+ java_lang_Throwable__getCause__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_channels_AsynchronousCloseException_class_s
+ java_nio_channels_AsynchronousCloseException__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_channels_AsynchronousCloseException_methods),
+  JCGO_STRREF_OF(jcgo_string1_AsncClEx),
+  JCGO_CLASSREF_OF(java_nio_channels_ClosedChannelException__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype117_GmCnnctn jcgo_array2_AsncClEx=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 44,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)121/*'y'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)115/*'s'*/,
+   (jbyte)(jchar)67/*'C'*/, (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)69/*'E'*/,
+   (jbyte)(jchar)120/*'x'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AsncClEx
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_AsncClEx),
+ 0, 44, (jint)0xef756df7L
+};
+
+#ifdef CHKALL_java_nio_channels_AsynchronousCloseException
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/AsncClEx.h

@@ -0,0 +1,58 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_nio_channels_AsynchronousCloseException CFASTCALL
+java_nio_channels_AsynchronousCloseException__this__( java_nio_channels_AsynchronousCloseException
+ This );
+JCGO_NOSEP_INLINE java_nio_channels_AsynchronousCloseException CFASTCALL
+java_nio_channels_AsynchronousCloseException__new__( void );
+
+struct java_nio_channels_AsynchronousCloseException_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_channels_AsynchronousCloseException (CFASTCALL *jcgo_thisRtn)(
+  java_nio_channels_AsynchronousCloseException This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Throwable This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getMessage__)( java_lang_Throwable This
+  );
+ java_lang_Throwable (CFASTCALL *getCause__)( java_lang_Throwable This
+  );
+};
+
+struct java_nio_channels_AsynchronousCloseException_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_nio_channels_AsynchronousCloseException_methods_s
+ java_nio_channels_AsynchronousCloseException_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_channels_AsynchronousCloseException_class_s
+ java_nio_channels_AsynchronousCloseException__class;
+
+struct java_nio_channels_AsynchronousCloseException_s
+{
+ CONST struct java_nio_channels_AsynchronousCloseException_methods_s
+  *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String detailMessage;
+ java_lang_Throwable cause;
+ jObjectArr stackTrace;
+ java_lang_VMThrowable vmState;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype117_GmCnnctn jcgo_array2_AsncClEx;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_AsncClEx;
+
+#endif

jcgo_Out/BZLib.h

@@ -0,0 +1,71 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE jbyte CFASTCALL
+package_BZLib__getUchar__L0h0mx( package_BZState state );
+
+JCGO_NOSEP_INLINE jbyte CFASTCALL
+package_BZLib__getBit__L0h0mx( package_BZState state );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+package_BZLib__makeMaps__L0h0mx( package_BZState state );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+package_BZLib__createDecodeTables__IAIAIABAIII( jintArr limit, jintArr
+ base, jintArr perm, jbyteArr length, jint minLen, jint maxLen, jint
+ alphaSize );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+package_BZLib__nextHeader__L0h0mx( package_BZState state );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+package_BZLib__decompress__L0h0mx( package_BZState state );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+package_BZLib__decompress__BAIBAII( jbyteArr out, jbyteArr in, jint
+ outSize, jint inSize, jint offset );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+package_BZLib__getBits__IL0h0mx( package_BZState state, jint i );
+
+JCGO_NOSEP_STATIC package_BZLib CFASTCALL
+package_BZLib__this__( package_BZLib This );
+
+struct package_BZLib_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ package_BZLib (CFASTCALL *jcgo_thisRtn)( package_BZLib This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct package_BZLib_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct package_BZLib_methods_s package_BZLib_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct package_BZLib_class_s package_BZLib__class;
+
+struct package_BZLib_s
+{
+ CONST struct package_BZLib_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype30_Object jcgo_array4_BZLib;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BZLib;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_BZLib;
+
+#endif

jcgo_Out/BZState.c

@@ -0,0 +1,113 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_BZState
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC package_BZState CFASTCALL
+package_BZState__this__( package_BZState This )
+{
+ {
+  ;
+  JCGO_FIELD_NZACCESS(This, unzftab)= (jintArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jint),
+   0, (jint)256);
+  JCGO_FIELD_NZACCESS(This, cftab)= (jintArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jint),
+   0, (jint)257);
+  JCGO_FIELD_NZACCESS(This, inUse)= (jbooleanArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jboolean),
+   0, (jint)256);
+  JCGO_FIELD_NZACCESS(This, inUse_16)= (jbooleanArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jboolean),
+   0, (jint)16);
+  JCGO_FIELD_NZACCESS(This, setToUnseq)= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+   0, (jint)256);
+  JCGO_FIELD_NZACCESS(This, mtfa)= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+   0, (jint)4096);
+  JCGO_FIELD_NZACCESS(This, mtfbase)= (jintArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jint),
+   0, (jint)16);
+  JCGO_FIELD_NZACCESS(This, selector)= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+   0, (jint)18002);
+  JCGO_FIELD_NZACCESS(This, selectorMtf)= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+   0, (jint)18002);
+  JCGO_FIELD_NZACCESS(This, len)= (jcgo_new4DArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+   2, 0, (jint)6, (jint)258, 0, 0));
+  JCGO_FIELD_NZACCESS(This, limit)= (jcgo_new4DArray(JCGO_CORECLASS_FOR(OBJT_jint),
+   2, 0, (jint)6, (jint)258, 0, 0));
+  JCGO_FIELD_NZACCESS(This, base)= (jcgo_new4DArray(JCGO_CORECLASS_FOR(OBJT_jint),
+   2, 0, (jint)6, (jint)258, 0, 0));
+  JCGO_FIELD_NZACCESS(This, perm)= (jcgo_new4DArray(JCGO_CORECLASS_FOR(OBJT_jint),
+   2, 0, (jint)6, (jint)258, 0, 0));
+  JCGO_FIELD_NZACCESS(This, minLens)= (jintArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jint),
+   0, (jint)6);
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE package_BZState CFASTCALL
+package_BZState__new__( void )
+{
+ return package_BZState__this__(
+  (package_BZState)jcgo_newObject((jvtable)&package_BZState_methods));
+}
+
+JCGO_NOSEP_DATA CONST struct package_BZState_methods_s package_BZState_methods=
+{
+ JCGO_CLASSREF_OF(package_BZState__class),
+ JCGO_GCJDESCR_INIT(package_BZState_s, minLens)
+ OBJT_package_BZState,
+ (JCGO_OBJSIZE_T)sizeof(struct package_BZState_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ package_BZState__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Object__toString__,
+ java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct package_BZState_class_s package_BZState__class
+ JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&package_BZState_methods),
+  JCGO_STRREF_OF(jcgo_string1_BZState),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x0
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype24_Object jcgo_array2_BZState=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 7,
+ {
+  (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)90/*'Z'*/, (jbyte)(jchar)83/*'S'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)101/*'e'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BZState
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BZState),
+ 0, 7, (jint)0x41b74319L
+};
+
+#ifdef CHKALL_BZState
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BZState.h

@@ -0,0 +1,82 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC package_BZState CFASTCALL
+package_BZState__this__( package_BZState This );
+JCGO_NOSEP_INLINE package_BZState CFASTCALL
+package_BZState__new__( void );
+
+struct package_BZState_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ package_BZState (CFASTCALL *jcgo_thisRtn)( package_BZState This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct package_BZState_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct package_BZState_methods_s package_BZState_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct package_BZState_class_s package_BZState__class;
+
+struct package_BZState_s
+{
+ CONST struct package_BZState_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jintArr tt;
+ jbyteArr input;
+ jbyteArr output;
+ jintArr unzftab;
+ jintArr cftab;
+ jbooleanArr inUse;
+ jbooleanArr inUse_16;
+ jbyteArr setToUnseq;
+ jbyteArr mtfa;
+ jintArr mtfbase;
+ jbyteArr selector;
+ jbyteArr selectorMtf;
+ jObjectArr len;
+ jObjectArr limit;
+ jObjectArr base;
+ jObjectArr perm;
+ jintArr minLens;
+ jint nextIn;
+ jint availIn;
+ jint totalInLo32;
+ jint totalInHi32;
+ jint availOut;
+ jint decompressedSize;
+ jint totalOutLo32;
+ jint totalOutHi32;
+ jint stateOutLen;
+ jint bsBuff;
+ jint bsLive;
+ jint blocksize100k;
+ jint blockNo;
+ jint origPtr;
+ jint tpos;
+ jint k0;
+ jint nblockUsed;
+ jint nInUse;
+ jint saveNblock;
+ jbyte stateOutCh;
+ jboolean blockRandomised;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype24_Object jcgo_array2_BZState;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BZState;
+
+#endif

jcgo_Out/BffrInSt.c

@@ -0,0 +1,311 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_io_BufferedInputStream
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_io_BufferedInputStream__void( java_io_BufferedInputStream This
+ )
+{
+ JCGO_FIELD_NZACCESS(This, markpos)= (-(jint)1);
+}
+
+JCGO_NOSEP_STATIC java_io_BufferedInputStream CFASTCALL
+java_io_BufferedInputStream__this__L0gpraI( java_io_BufferedInputStream
+ This, java_io_InputStream in, jint size )
+{
+ {
+  (java_io_FilterInputStream__this__L0gpra((java_io_FilterInputStream)This,
+   in));
+  java_io_BufferedInputStream__void(This);
+  if (size <= 0)
+  {
+   JCGO_THROW_EXC(java_lang_IllegalArgumentException__new__());
+  }
+  if (in != jnull)
+  {
+   JCGO_FIELD_NZACCESS(This, buf)= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+    0, size);
+   JCGO_FIELD_NZACCESS(This, pos)= JCGO_FIELD_NZACCESS(This, count)=
+    size;
+  }
+  JCGO_FIELD_NZACCESS(This, bufferSize)= size;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_io_BufferedInputStream CFASTCALL
+java_io_BufferedInputStream__this__L0gpra( java_io_BufferedInputStream
+ This, java_io_InputStream in )
+{
+ {
+  (java_io_BufferedInputStream__this__L0gpraI((java_io_BufferedInputStream)This,
+   in, java_io_BufferedInputStream__DEFAULT_BUFFER_SIZE));
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_io_BufferedInputStream CFASTCALL
+java_io_BufferedInputStream__new__L0gpra( java_io_InputStream in )
+{
+ return java_io_BufferedInputStream__this__L0gpra(
+  (java_io_BufferedInputStream)jcgo_newObject((jvtable)&java_io_BufferedInputStream_methods),
+  in);
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_BufferedInputStream__available__( java_io_BufferedInputStream
+ This )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  jint jcgo_rcvrI1;
+  if (JCGO_FIELD_NZACCESS(This, buf) == jnull)
+  {
+   JCGO_THROW_EXC((java_io_IOException__new__Ls(
+    JCGO_STRREF_OF(jcgo_string4_PrntStrm))));
+  }
+  {
+   jint jcgo_retval= (jcgo_rcvrI1= JCGO_FIELD_NZACCESS(This, count) -
+    JCGO_FIELD_NZACCESS(This, pos), jcgo_rcvrI1 + (java_io_FilterInputStream__available__(
+    (java_io_FilterInputStream)This)));
+#ifndef JCGO_SEHTRY
+   JCGO_SYNC_JUMPLEAVE(0);
+#endif
+   return jcgo_retval;
+  }
+ }
+ JCGO_SYNC_ENDUNREACH
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_BufferedInputStream__close__( java_io_BufferedInputStream
+ This )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, buf) != jnull)
+  {
+   JCGO_FIELD_NZACCESS(This, buf)= (jbyteArr)jnull;
+   JCGO_FIELD_NZACCESS(This, pos)= JCGO_FIELD_NZACCESS(This, count)=
+    0;
+   JCGO_FIELD_NZACCESS(This, markpos)= (-(jint)1);
+   (java_io_FilterInputStream__close__(
+    (java_io_FilterInputStream)This));
+  }
+ }
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_BufferedInputStream__read__( java_io_BufferedInputStream This
+ )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  jObject jcgo_rcvrL1;
+  if (JCGO_FIELD_NZACCESS(This, pos) >= JCGO_FIELD_NZACCESS(This, count) &&
+   !(java_io_BufferedInputStream__refill__(
+   This)))
+  {
+#ifndef JCGO_SEHTRY
+   JCGO_SYNC_JUMPLEAVE(0);
+#endif
+   return (-(jint)1);
+  }
+  {
+   jint jcgo_retval= (jint)((unsigned char)(jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This,
+    buf), JCGO_ARRAY_BACCESS((jbyteArr)jcgo_rcvrL1, JCGO_FIELD_NZACCESS(This,
+    pos)++)));
+#ifndef JCGO_SEHTRY
+   JCGO_SYNC_JUMPLEAVE(0);
+#endif
+   return jcgo_retval;
+  }
+ }
+ JCGO_SYNC_ENDUNREACH
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_BufferedInputStream__read__BAII( java_io_BufferedInputStream
+ This, jbyteArr b, jint off, jint len )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  jint totalBytesRead;
+  if (off < 0 || len < 0 || JCGO_ARRAY_LENGTH(b) - off < len)
+  {
+   JCGO_THROW_EXC(java_lang_IndexOutOfBoundsException__new__());
+  }
+  if (len == 0)
+  {
+#ifndef JCGO_SEHTRY
+   JCGO_SYNC_JUMPLEAVE(0);
+#endif
+   return 0;
+  }
+  if (JCGO_FIELD_NZACCESS(This, pos) >= JCGO_FIELD_NZACCESS(This, count) &&
+   !(java_io_BufferedInputStream__refill__(
+   This)))
+  {
+#ifndef JCGO_SEHTRY
+   JCGO_SYNC_JUMPLEAVE(0);
+#endif
+   return (-(jint)1);
+  }
+  totalBytesRead= (java_lang_Math__min__II(
+   JCGO_FIELD_NZACCESS(This, count) - JCGO_FIELD_NZACCESS(This, pos),
+   len));
+  (java_lang_System__arraycopy__LoILoII(
+   (java_lang_Object)JCGO_FIELD_NZACCESS(This, buf), (java_lang_Object)b,
+   JCGO_FIELD_NZACCESS(This, pos), off, totalBytesRead));
+  JCGO_FIELD_NZACCESS(This, pos)+= totalBytesRead;
+  off+= totalBytesRead;
+  len-= totalBytesRead;
+  while (len > 0 && (java_io_FilterInputStream__available__(
+   (java_io_FilterInputStream)This)) > 0 && (java_io_BufferedInputStream__refill__(
+   This)))
+  {
+   jint remain;
+   remain= (java_lang_Math__min__II(
+    JCGO_FIELD_NZACCESS(This, count) - JCGO_FIELD_NZACCESS(This, pos),
+    len));
+   (java_lang_System__arraycopy__LoILoII(
+    (java_lang_Object)JCGO_FIELD_NZACCESS(This, buf), (java_lang_Object)b,
+    JCGO_FIELD_NZACCESS(This, pos), off, remain));
+   JCGO_FIELD_NZACCESS(This, pos)+= remain;
+   off+= remain;
+   len-= remain;
+   totalBytesRead+= remain;
+  }
+#ifndef JCGO_SEHTRY
+  JCGO_SYNC_JUMPLEAVE(0);
+#endif
+  return totalBytesRead;
+ }
+ JCGO_SYNC_ENDUNREACH
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_io_BufferedInputStream__refill__( java_io_BufferedInputStream
+ This )
+{
+ {
+  jint numread;
+  if (JCGO_FIELD_NZACCESS(This, buf) == jnull)
+  {
+   JCGO_THROW_EXC((java_io_IOException__new__Ls(
+    JCGO_STRREF_OF(jcgo_string4_PrntStrm))));
+  }
+  if (JCGO_FIELD_NZACCESS(This, markpos) == (-(jint)1) || JCGO_FIELD_NZACCESS(This,
+   count) - JCGO_FIELD_NZACCESS(This, markpos) >= (jint)0)
+  {
+   JCGO_FIELD_NZACCESS(This, markpos)= (-(jint)1);
+   JCGO_FIELD_NZACCESS(This, pos)= JCGO_FIELD_NZACCESS(This, count)=
+    0;
+  }
+  else
+  {
+   jbyteArr newbuf;
+   newbuf= JCGO_FIELD_NZACCESS(This, buf);
+   if (JCGO_FIELD_NZACCESS(This, markpos) < JCGO_FIELD_NZACCESS(This,
+    bufferSize))
+   {
+    newbuf= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+     0, JCGO_FIELD_NZACCESS(This, count) - JCGO_FIELD_NZACCESS(This,
+     markpos) + JCGO_FIELD_NZACCESS(This, bufferSize));
+   }
+   (java_lang_System__arraycopy__LoILoII(
+    (java_lang_Object)JCGO_FIELD_NZACCESS(This, buf), (java_lang_Object)newbuf,
+    JCGO_FIELD_NZACCESS(This, markpos), 0, JCGO_FIELD_NZACCESS(This,
+    count) - JCGO_FIELD_NZACCESS(This, markpos)));
+   JCGO_FIELD_NZACCESS(This, buf)= newbuf;
+   JCGO_FIELD_NZACCESS(This, count)-= JCGO_FIELD_NZACCESS(This, markpos);
+   JCGO_FIELD_NZACCESS(This, pos)-= JCGO_FIELD_NZACCESS(This, markpos);
+   JCGO_FIELD_NZACCESS(This, markpos)= 0;
+  }
+  numread= (java_io_FilterInputStream__read__BAII(
+   (java_io_FilterInputStream)This, JCGO_FIELD_NZACCESS(This, buf),
+   JCGO_FIELD_NZACCESS(This, count), JCGO_FIELD_NZACCESS(This, bufferSize)));
+  if (numread <= 0)
+  {
+   return (jboolean)jfalse;
+  }
+  JCGO_FIELD_NZACCESS(This, count)+= numread;
+  return (jboolean)jtrue;
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct java_io_BufferedInputStream_methods_s
+ java_io_BufferedInputStream_methods=
+{
+ JCGO_CLASSREF_OF(java_io_BufferedInputStream__class),
+ JCGO_GCJDESCR_INIT(java_io_BufferedInputStream_s, buf)
+ OBJT_java_io_BufferedInputStream,
+ (JCGO_OBJSIZE_T)sizeof(struct java_io_BufferedInputStream_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Object__toString__,
+ java_lang_Object__finalize__,
+ java_io_BufferedInputStream__available__,
+ java_io_BufferedInputStream__close__,
+ java_io_BufferedInputStream__read__,
+ java_io_BufferedInputStream__read__BAII
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_io_BufferedInputStream_class_s
+ java_io_BufferedInputStream__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_io_BufferedInputStream_methods),
+  JCGO_STRREF_OF(jcgo_string1_BffrInSt),
+  JCGO_CLASSREF_OF(java_io_FilterInputStream__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype38_Object jcgo_array2_BffrInSt=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 27,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)66/*'B'*/,
+   (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)102/*'f'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)100/*'d'*/, (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)83/*'S'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)109/*'m'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BffrInSt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BffrInSt),
+ 0, 27, (jint)0xc5ec1defL
+};
+
+#ifdef CHKALL_java_io_BufferedInputStream
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BffrInSt.h

@@ -0,0 +1,90 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+#define java_io_BufferedInputStream__DEFAULT_BUFFER_SIZE (jint)2048
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_io_BufferedInputStream__void( java_io_BufferedInputStream This
+ );
+
+JCGO_NOSEP_STATIC java_io_BufferedInputStream CFASTCALL
+java_io_BufferedInputStream__this__L0gpraI( java_io_BufferedInputStream
+ This, java_io_InputStream in, jint size );
+
+JCGO_NOSEP_INLINE java_io_BufferedInputStream CFASTCALL
+java_io_BufferedInputStream__this__L0gpra( java_io_BufferedInputStream
+ This, java_io_InputStream in );
+JCGO_NOSEP_FRWINL java_io_BufferedInputStream CFASTCALL
+java_io_BufferedInputStream__new__L0gpra( java_io_InputStream in );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_BufferedInputStream__available__( java_io_BufferedInputStream
+ This );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_BufferedInputStream__close__( java_io_BufferedInputStream
+ This );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_BufferedInputStream__read__( java_io_BufferedInputStream This
+ );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_BufferedInputStream__read__BAII( java_io_BufferedInputStream
+ This, jbyteArr b, jint off, jint len );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_io_BufferedInputStream__refill__( java_io_BufferedInputStream
+ This );
+
+struct java_io_BufferedInputStream_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_io_BufferedInputStream (CFASTCALL *jcgo_thisRtn)( java_io_BufferedInputStream
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jint (CFASTCALL *available__)( java_io_BufferedInputStream This );
+ void (CFASTCALL *close__)( java_io_BufferedInputStream This );
+ jint (CFASTCALL *read__)( java_io_BufferedInputStream This );
+ jint (CFASTCALL *read__BAII)( java_io_BufferedInputStream This, jbyteArr
+  b, jint off, jint len );
+};
+
+struct java_io_BufferedInputStream_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_io_BufferedInputStream_methods_s
+ java_io_BufferedInputStream_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_io_BufferedInputStream_class_s
+ java_io_BufferedInputStream__class;
+
+struct java_io_BufferedInputStream_s
+{
+ CONST struct java_io_BufferedInputStream_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_io_InputStream in;
+ jbyteArr buf;
+ jint count;
+ jint pos;
+ jint markpos;
+ jint bufferSize;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype38_Object jcgo_array2_BffrInSt;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BffrInSt;
+
+#endif

jcgo_Out/BffrOtSt.c

@@ -0,0 +1,189 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_io_BufferedOutputStream
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_io_BufferedOutputStream CFASTCALL
+java_io_BufferedOutputStream__this__L0rv4gI( java_io_BufferedOutputStream
+ This, java_io_OutputStream out, jint size )
+{
+ {
+  (java_io_FilterOutputStream__this__L0rv4g((java_io_FilterOutputStream)This,
+   out));
+  if (size <= 0)
+  {
+   JCGO_THROW_EXC(java_lang_IllegalArgumentException__new__());
+  }
+  JCGO_FIELD_NZACCESS(This, buf)= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+   0, size);
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_io_BufferedOutputStream CFASTCALL
+java_io_BufferedOutputStream__new__L0rv4gI( java_io_OutputStream out,
+ jint size )
+{
+ return java_io_BufferedOutputStream__this__L0rv4gI(
+  (java_io_BufferedOutputStream)jcgo_newObject((jvtable)&java_io_BufferedOutputStream_methods),
+  out, size);
+}
+
+JCGO_NOSEP_INLINE java_io_BufferedOutputStream CFASTCALL
+java_io_BufferedOutputStream__this__L0rv4g( java_io_BufferedOutputStream
+ This, java_io_OutputStream out )
+{
+ {
+  (java_io_BufferedOutputStream__this__L0rv4gI((java_io_BufferedOutputStream)This,
+   out, java_io_BufferedOutputStream__DEFAULT_BUFFER_SIZE));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_io_BufferedOutputStream CFASTCALL
+java_io_BufferedOutputStream__new__L0rv4g( java_io_OutputStream out
+ )
+{
+ return java_io_BufferedOutputStream__this__L0rv4g(
+  (java_io_BufferedOutputStream)jcgo_newObject((jvtable)&java_io_BufferedOutputStream_methods),
+  out);
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_BufferedOutputStream__flushBuffer__( java_io_BufferedOutputStream
+ This )
+{
+ {
+  jObject jcgo_rcvrL1;
+  if (JCGO_FIELD_NZACCESS(This, count) == 0)
+  {
+   return;
+  }
+  (jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This, out), JCGO_CALL_VFUNC((java_io_OutputStream)jcgo_rcvrL1)->write__BAII(
+   (java_io_OutputStream)jcgo_rcvrL1, JCGO_FIELD_NZACCESS(This, buf),
+   0, JCGO_FIELD_NZACCESS(This, count)));
+  JCGO_FIELD_NZACCESS(This, count)= 0;
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_BufferedOutputStream__write__BAII( java_io_BufferedOutputStream
+ This, jbyteArr buf, jint offset, jint len )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  if (len < JCGO_ARRAY_LENGTH(JCGO_FIELD_NZACCESS(This, buf)))
+  {
+   if (len > JCGO_ARRAY_LENGTH(JCGO_FIELD_NZACCESS(This, buf)) - JCGO_FIELD_NZACCESS(This,
+    count))
+   {
+    (java_io_BufferedOutputStream__flushBuffer__(
+     This));
+   }
+   (java_lang_System__arraycopy__LoILoII(
+    (java_lang_Object)buf, (java_lang_Object)(JCGO_FIELD_NZACCESS(This,
+    buf)), offset, JCGO_FIELD_NZACCESS(This, count), len));
+   JCGO_FIELD_NZACCESS(This, count)+= len;
+  }
+  else
+  {
+   jObject jcgo_rcvrL1;
+   (java_io_BufferedOutputStream__flushBuffer__(
+    This));
+   (jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This, out), JCGO_CALL_VFUNC((java_io_OutputStream)jcgo_rcvrL1)->write__BAII(
+    (java_io_OutputStream)jcgo_rcvrL1, buf, offset, len));
+  }
+ }
+ JCGO_SYNC_END
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_BufferedOutputStream__flush__( java_io_BufferedOutputStream
+ This )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  jObject jcgo_rcvrL1;
+  (java_io_BufferedOutputStream__flushBuffer__(
+   This));
+  (jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This, out), JCGO_CALL_VFUNC((java_io_OutputStream)jcgo_rcvrL1)->flush__(
+   (java_io_OutputStream)jcgo_rcvrL1));
+ }
+ JCGO_SYNC_END
+}
+
+JCGO_NOSEP_DATA CONST struct java_io_BufferedOutputStream_methods_s
+ java_io_BufferedOutputStream_methods=
+{
+ JCGO_CLASSREF_OF(java_io_BufferedOutputStream__class),
+ JCGO_GCJDESCR_INIT(java_io_BufferedOutputStream_s, buf)
+ OBJT_java_io_BufferedOutputStream,
+ (JCGO_OBJSIZE_T)sizeof(struct java_io_BufferedOutputStream_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Object__toString__,
+ java_lang_Object__finalize__,
+ java_io_BufferedOutputStream__write__BAII,
+ java_io_BufferedOutputStream__flush__,
+ java_io_FilterOutputStream__close__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_io_BufferedOutputStream_class_s
+ java_io_BufferedOutputStream__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_io_BufferedOutputStream_methods),
+  JCGO_STRREF_OF(jcgo_string1_BffrOtSt),
+  JCGO_CLASSREF_OF(java_io_FilterOutputStream__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype90_GmCnnctn jcgo_array2_BffrOtSt=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 28,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)66/*'B'*/,
+   (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)102/*'f'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)100/*'d'*/, (jbyte)(jchar)79/*'O'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)83/*'S'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)109/*'m'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BffrOtSt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BffrOtSt),
+ 0, 28, (jint)0x2533067cL
+};
+
+#ifdef CHKALL_java_io_BufferedOutputStream
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BffrOtSt.h

@@ -0,0 +1,78 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+#define java_io_BufferedOutputStream__DEFAULT_BUFFER_SIZE (jint)512
+
+JCGO_NOSEP_STATIC java_io_BufferedOutputStream CFASTCALL
+java_io_BufferedOutputStream__this__L0rv4gI( java_io_BufferedOutputStream
+ This, java_io_OutputStream out, jint size );
+JCGO_NOSEP_FRWINL java_io_BufferedOutputStream CFASTCALL
+java_io_BufferedOutputStream__new__L0rv4gI( java_io_OutputStream out,
+ jint size );
+
+JCGO_NOSEP_INLINE java_io_BufferedOutputStream CFASTCALL
+java_io_BufferedOutputStream__this__L0rv4g( java_io_BufferedOutputStream
+ This, java_io_OutputStream out );
+JCGO_NOSEP_INLINE java_io_BufferedOutputStream CFASTCALL
+java_io_BufferedOutputStream__new__L0rv4g( java_io_OutputStream out
+ );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_BufferedOutputStream__flushBuffer__( java_io_BufferedOutputStream
+ This );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_BufferedOutputStream__write__BAII( java_io_BufferedOutputStream
+ This, jbyteArr buf, jint offset, jint len );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_BufferedOutputStream__flush__( java_io_BufferedOutputStream
+ This );
+
+struct java_io_BufferedOutputStream_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_io_BufferedOutputStream (CFASTCALL *jcgo_thisRtn)( java_io_BufferedOutputStream
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ void (CFASTCALL *write__BAII)( java_io_BufferedOutputStream This,
+  jbyteArr buf, jint offset, jint len );
+ void (CFASTCALL *flush__)( java_io_BufferedOutputStream This );
+ void (CFASTCALL *close__)( java_io_FilterOutputStream This );
+};
+
+struct java_io_BufferedOutputStream_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_io_BufferedOutputStream_methods_s
+ java_io_BufferedOutputStream_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_io_BufferedOutputStream_class_s
+ java_io_BufferedOutputStream__class;
+
+struct java_io_BufferedOutputStream_s
+{
+ CONST struct java_io_BufferedOutputStream_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_io_OutputStream out;
+ jbyteArr buf;
+ jint count;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype90_GmCnnctn jcgo_array2_BffrOtSt;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BffrOtSt;
+
+#endif

jcgo_Out/BffrOvEx.c

@@ -0,0 +1,77 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_BufferOverflowException
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_nio_BufferOverflowException CFASTCALL
+java_nio_BufferOverflowException__this__( java_nio_BufferOverflowException
+ This )
+{
+ {
+  (java_lang_RuntimeException__this__((java_lang_RuntimeException)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_nio_BufferOverflowException CFASTCALL
+java_nio_BufferOverflowException__new__( void )
+{
+ return java_nio_BufferOverflowException__this__(
+  (java_nio_BufferOverflowException)jcgo_newObject((jvtable)&java_nio_BufferOverflowException_methods));
+}
+
+JCGO_NOSEP_DATA CONST struct java_nio_BufferOverflowException_methods_s
+ java_nio_BufferOverflowException_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_BufferOverflowException__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_BufferOverflowException,
+ (JCGO_OBJSIZE_T)sizeof(struct java_nio_BufferOverflowException_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_nio_BufferOverflowException__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Throwable__toString__,
+ java_lang_Object__finalize__,
+ java_lang_Throwable__getMessage__,
+ java_lang_Throwable__getCause__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_BufferOverflowException_class_s
+ java_nio_BufferOverflowException__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_BufferOverflowException_methods),
+  JCGO_STRREF_OF(jcgo_string1_BffrOvEx),
+  JCGO_CLASSREF_OF(java_lang_RuntimeException__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BffrOvEx
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BufferBD),
+ 0, 32, (jint)0x3b81da47L
+};
+
+#ifdef CHKALL_java_nio_BufferOverflowException
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BffrOvEx.h

@@ -0,0 +1,56 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_nio_BufferOverflowException CFASTCALL
+java_nio_BufferOverflowException__this__( java_nio_BufferOverflowException
+ This );
+JCGO_NOSEP_INLINE java_nio_BufferOverflowException CFASTCALL
+java_nio_BufferOverflowException__new__( void );
+
+struct java_nio_BufferOverflowException_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_BufferOverflowException (CFASTCALL *jcgo_thisRtn)( java_nio_BufferOverflowException
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Throwable This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getMessage__)( java_lang_Throwable This
+  );
+ java_lang_Throwable (CFASTCALL *getCause__)( java_lang_Throwable This
+  );
+};
+
+struct java_nio_BufferOverflowException_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_nio_BufferOverflowException_methods_s
+ java_nio_BufferOverflowException_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_BufferOverflowException_class_s
+ java_nio_BufferOverflowException__class;
+
+struct java_nio_BufferOverflowException_s
+{
+ CONST struct java_nio_BufferOverflowException_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String detailMessage;
+ java_lang_Throwable cause;
+ jObjectArr stackTrace;
+ java_lang_VMThrowable vmState;
+};
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BffrOvEx;
+
+#endif

jcgo_Out/BffrUnEx.c

@@ -0,0 +1,97 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_BufferUnderflowException
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_nio_BufferUnderflowException CFASTCALL
+java_nio_BufferUnderflowException__this__( java_nio_BufferUnderflowException
+ This )
+{
+ {
+  (java_lang_RuntimeException__this__((java_lang_RuntimeException)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_nio_BufferUnderflowException CFASTCALL
+java_nio_BufferUnderflowException__new__( void )
+{
+ return java_nio_BufferUnderflowException__this__(
+  (java_nio_BufferUnderflowException)jcgo_newObject((jvtable)&java_nio_BufferUnderflowException_methods));
+}
+
+JCGO_NOSEP_DATA CONST struct java_nio_BufferUnderflowException_methods_s
+ java_nio_BufferUnderflowException_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_BufferUnderflowException__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_BufferUnderflowException,
+ (JCGO_OBJSIZE_T)sizeof(struct java_nio_BufferUnderflowException_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_nio_BufferUnderflowException__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Throwable__toString__,
+ java_lang_Object__finalize__,
+ java_lang_Throwable__getMessage__,
+ java_lang_Throwable__getCause__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_BufferUnderflowException_class_s
+ java_nio_BufferUnderflowException__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_BufferUnderflowException_methods),
+  JCGO_STRREF_OF(jcgo_string1_BffrUnEx),
+  JCGO_CLASSREF_OF(java_lang_RuntimeException__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype48_GameShll jcgo_array2_BffrUnEx=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 33,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)102/*'f'*/,
+   (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)85/*'U'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)100/*'d'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)102/*'f'*/,
+   (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)119/*'w'*/,
+   (jbyte)(jchar)69/*'E'*/, (jbyte)(jchar)120/*'x'*/, (jbyte)(jchar)99/*'c'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BffrUnEx
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BffrUnEx),
+ 0, 33, (jint)0x4fa1be4fL
+};
+
+#ifdef CHKALL_java_nio_BufferUnderflowException
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BffrUnEx.h

@@ -0,0 +1,58 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_nio_BufferUnderflowException CFASTCALL
+java_nio_BufferUnderflowException__this__( java_nio_BufferUnderflowException
+ This );
+JCGO_NOSEP_INLINE java_nio_BufferUnderflowException CFASTCALL
+java_nio_BufferUnderflowException__new__( void );
+
+struct java_nio_BufferUnderflowException_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_BufferUnderflowException (CFASTCALL *jcgo_thisRtn)( java_nio_BufferUnderflowException
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Throwable This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getMessage__)( java_lang_Throwable This
+  );
+ java_lang_Throwable (CFASTCALL *getCause__)( java_lang_Throwable This
+  );
+};
+
+struct java_nio_BufferUnderflowException_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_nio_BufferUnderflowException_methods_s
+ java_nio_BufferUnderflowException_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_BufferUnderflowException_class_s
+ java_nio_BufferUnderflowException__class;
+
+struct java_nio_BufferUnderflowException_s
+{
+ CONST struct java_nio_BufferUnderflowException_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String detailMessage;
+ java_lang_Throwable cause;
+ jObjectArr stackTrace;
+ java_lang_VMThrowable vmState;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype48_GameShll jcgo_array2_BffrUnEx;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BffrUnEx;
+
+#endif

jcgo_Out/BigIntgr.c

@@ -0,0 +1,694 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_math_BigInteger
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_math_BigInteger__void( java_math_BigInteger This )
+{
+}
+
+JCGO_NOSEP_STATIC java_math_BigInteger CFASTCALL
+java_math_BigInteger__this__LsI( java_math_BigInteger This, java_lang_String
+ val, jint radix )
+{
+ {
+  java_math_BigInteger result;
+  (java_lang_Number__this__((java_lang_Number)This));
+  result= (java_math_BigInteger__valueOf__LsI(
+   val, radix));
+  JCGO_FIELD_NZACCESS(This, ival)= JCGO_FIELD_ACCESS(java_math_BigInteger,
+   result, ival);
+  JCGO_FIELD_NZACCESS(This, words)= JCGO_FIELD_NZACCESS(result, words);
+ }
+ return This;
+}
+
+JCGO_NOSEP_STATIC java_math_BigInteger CFASTCALL
+java_math_BigInteger__this__I( java_math_BigInteger This, jint value
+ )
+{
+ {
+  (java_lang_Number__this__((java_lang_Number)This));
+  JCGO_FIELD_NZACCESS(This, ival)= value;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__new__I( jint value )
+{
+ return java_math_BigInteger__this__I(
+  (java_math_BigInteger)jcgo_newObject((jvtable)&java_math_BigInteger_methods),
+  value);
+}
+
+JCGO_NOSEP_STATIC java_math_BigInteger CFASTCALL
+java_math_BigInteger__this__( java_math_BigInteger This )
+{
+ {
+  (java_lang_Number__this__((java_lang_Number)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__new__( void )
+{
+ return java_math_BigInteger__this__(
+  (java_math_BigInteger)jcgo_newObject((jvtable)&java_math_BigInteger_methods));
+}
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__alloc__I( jint nwords )
+{
+ {
+  java_math_BigInteger result;
+  result= java_math_BigInteger__new__();
+  if (nwords > (jint)1)
+  {
+   JCGO_FIELD_NZACCESS(result, words)= (jintArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jint),
+    0, nwords);
+  }
+  return result;
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_math_BigInteger__wordsNeeded__IAI( jintArr words, jint len )
+{
+ {
+  jint i;
+  i= len;
+  if (i > 0)
+  {
+   jint word;
+   word= JCGO_ARRAY_IACCESS(words, --i);
+   if (word == (-(jint)1))
+   {
+    while (i > 0 && (word= JCGO_ARRAY_NZIACCESS(words, i - (jint)1)) <
+     0)
+    {
+     i--;
+     if (word != (-(jint)1))
+     {
+      break;
+     }
+    }
+   }
+   else
+   {
+    while (word == 0 && i > 0 && (word= JCGO_ARRAY_NZIACCESS(words,
+     i - (jint)1)) >= 0)
+    {
+     i--;
+    }
+   }
+  }
+  return i + (jint)1;
+ }
+}
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__make__IAI( jintArr words, jint len )
+{
+ {
+  java_math_BigInteger num;
+  if (words == jnull)
+  {
+   return (java_math_BigInteger__valueOf__J(
+    (jlong)len));
+  }
+  len= (java_math_BigInteger__wordsNeeded__IAI(
+   words, len));
+  if (len <= (jint)1)
+  {
+   return len == 0? java_math_BigInteger__ZERO : (java_math_BigInteger__valueOf__J(
+    (jlong)(JCGO_ARRAY_NZIACCESS(words, 0))));
+  }
+  num= java_math_BigInteger__new__();
+  JCGO_FIELD_NZACCESS(num, words)= words;
+  JCGO_FIELD_NZACCESS(num, ival)= len;
+  return num;
+ }
+}
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__valueOf__BAIZI( jbyteArr digits, jint byte_len,
+ jint radix, jboolean negative )
+{
+ {
+  jintArr words;
+  jint chars_per_word;
+  jint size;
+  chars_per_word= (gnu_java_math_MPN__chars_per_word__I(
+   radix));
+  words= (jintArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jint), 0, jcgo_div(byte_len,
+   chars_per_word) + (jint)1);
+  size= (gnu_java_math_MPN__set_str__IABAII(
+   words, digits, byte_len, radix));
+  if (size == 0)
+  {
+   return java_math_BigInteger__ZERO;
+  }
+  if (JCGO_ARRAY_NZIACCESS(words, size - (jint)1) < 0)
+  {
+   JCGO_ARRAY_NZIACCESS(words, size++)= 0;
+  }
+  if (negative)
+  {
+   (java_math_BigInteger__negate__IAIAI(
+    words, words, size));
+  }
+  return (java_math_BigInteger__make__IAI(
+   words, size));
+ }
+}
+
+JCGO_NOSEP_FRWINL java_math_BigInteger CFASTCALL
+java_math_BigInteger__valueOf__LsI( java_lang_String s, jint radix
+ )
+{
+ {
+  jbyteArr bytes;
+  jint len;
+  jint i;
+  jint digit;
+  jint byte_len;
+  jchar ch;
+  jboolean negative;
+  len= (JCGO_CALL_FINALF(s) java_lang_String__length__(
+   s));
+  if (len <= (jint)15 && radix <= (jint)16)
+  {
+   return (java_math_BigInteger__valueOf__J(
+    (java_lang_Long__parseLong__LsI(
+    s, radix))));
+  }
+  ;
+  ch= (java_lang_String__charAt__I(
+   s, 0));
+  if (ch == (jchar)45/*'-'*/)
+  {
+   negative= (jboolean)jtrue;
+   i= (jint)1;
+   bytes= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte), 0,
+    len - (jint)1);
+  }
+  else
+  {
+   negative= (jboolean)jfalse;
+   i= 0;
+   bytes= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte), 0,
+    len);
+  }
+  byte_len= 0;
+  for (; i < len; i++)
+  {
+   ch= (java_lang_String__charAt__I(
+    s, i));
+   digit= (java_lang_Character__digit__CI(
+    radix, ch));
+   if (digit < 0)
+   {
+    JCGO_THROW_EXC(java_lang_NumberFormatException__new__());
+   }
+   JCGO_ARRAY_NZBACCESS(bytes, byte_len++)= ((jbyte)digit);
+  }
+  return (java_math_BigInteger__valueOf__BAIZI(
+   bytes, byte_len, radix, (jboolean)negative));
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_math_BigInteger__equals__L03o76L03o76( java_math_BigInteger x,
+ java_math_BigInteger y )
+{
+ {
+  if (JCGO_FIELD_ACCESS(java_math_BigInteger, x, words) == jnull &&
+   JCGO_FIELD_ACCESS(java_math_BigInteger, y, words) == jnull)
+  {
+   return (jboolean)(JCGO_FIELD_NZACCESS(x, ival) == JCGO_FIELD_ACCESS(java_math_BigInteger,
+    y, ival));
+  }
+  if (JCGO_FIELD_NZACCESS(x, words) == jnull || JCGO_FIELD_ACCESS(java_math_BigInteger,
+   y, words) == jnull || JCGO_FIELD_NZACCESS(x, ival) != JCGO_FIELD_ACCESS(java_math_BigInteger,
+   y, ival))
+  {
+   return (jboolean)jfalse;
+  }
+  {
+   jint i;
+   i= JCGO_FIELD_NZACCESS(x, ival);
+   for (; --i >= 0;)
+   {
+    jint jcgo_rcvrI1;
+    if ((jcgo_rcvrI1= JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(x, words),
+     i), jcgo_rcvrI1 != JCGO_ARRAY_IACCESS(JCGO_FIELD_ACCESS(java_math_BigInteger,
+     y, words), i)))
+    {
+     return (jboolean)jfalse;
+    }
+   }
+  }
+  return (jboolean)jtrue;
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_math_BigInteger__isNegative__( java_math_BigInteger This )
+{
+ {
+  return (jboolean)((JCGO_FIELD_NZACCESS(This, words) == jnull? JCGO_FIELD_NZACCESS(This,
+   ival) : JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(This, words), JCGO_FIELD_NZACCESS(This,
+   ival) - (jint)1)) < 0);
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_math_BigInteger__getAbsolute__IA( java_math_BigInteger This,
+ jintArr words )
+{
+ {
+  jint len;
+  if (JCGO_FIELD_NZACCESS(This, words) == jnull)
+  {
+   len= (jint)1;
+   JCGO_ARRAY_IACCESS(words, 0)= (JCGO_FIELD_NZACCESS(This, ival));
+  }
+  else
+  {
+   len= JCGO_FIELD_NZACCESS(This, ival);
+   {
+    jint i;
+    i= len;
+    for (; --i >= 0;)
+    {
+     jint jcgo_rcvrI1;
+     (jcgo_rcvrI1= JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(This, words),
+      i), JCGO_ARRAY_IACCESS(words, i)= jcgo_rcvrI1);
+    }
+   }
+  }
+  if (JCGO_ARRAY_IACCESS(words, len - (jint)1) < 0)
+  {
+   (java_math_BigInteger__negate__IAIAI(
+    words, words, len));
+  }
+  {
+   jint i;
+   i= JCGO_ARRAY_NZLENGTH(words);
+   for (; --i > len;)
+   {
+    JCGO_ARRAY_NZIACCESS(words, i)= 0;
+   }
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_math_BigInteger__format__IL8whtv( java_math_BigInteger This,
+ java_lang_StringBuffer buffer, jint radix )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, words) == jnull)
+  {
+   struct java_lang_String_s jcgo_stackobj1;
+   (JCGO_CALL_FINALF(buffer) java_lang_StringBuffer__append__Ls(
+    buffer, (java_lang_Integer__toString__IIX(
+    JCGO_FIELD_NZACCESS(This, ival), radix, JCGO_STACKOBJ_NEW(jcgo_stackobj1,
+    java_lang_String_methods)))));
+  }
+  else
+  {
+   if (JCGO_FIELD_NZACCESS(This, ival) <= (jint)2)
+   {
+    (JCGO_CALL_FINALF(buffer) java_lang_StringBuffer__append__Ls(
+     buffer, (java_lang_Long__toString__JI(
+     (java_math_BigInteger__longValue__(
+     This)), radix))));
+   }
+   else
+   {
+    jintArr work;
+    jint len;
+    jboolean neg;
+    neg= (java_math_BigInteger__isNegative__(
+     This));
+    if (neg || radix != (jint)16)
+    {
+     work= (jintArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jint), 0,
+      JCGO_FIELD_NZACCESS(This, ival));
+     (java_math_BigInteger__getAbsolute__IA(
+      This, work));
+    }
+    else
+    {
+     work= JCGO_FIELD_NZACCESS(This, words);
+    }
+    len= JCGO_FIELD_NZACCESS(This, ival);
+    if (radix == (jint)16)
+    {
+     jint buf_start;
+     if (neg)
+     {
+      (JCGO_CALL_FINALF(buffer) java_lang_StringBuffer__append__C(
+       buffer, (jchar)45/*'-'*/));
+     }
+     buf_start= (JCGO_CALL_FINALF(buffer) java_lang_StringBuffer__length__(
+      buffer));
+     {
+      jint i;
+      i= len;
+      for (; --i >= 0;)
+      {
+       jint word;
+       word= JCGO_ARRAY_IACCESS(work, i);
+       {
+        jint j;
+        j= (jint)8;
+        for (; --j >= 0;)
+        {
+         jint hex_digit;
+         hex_digit= JCGO_SHR_F(word, (j * (jint)4)) & (jint)15;
+         if (hex_digit > 0 || (java_lang_StringBuffer__length__(
+          buffer)) > buf_start)
+         {
+          (java_lang_StringBuffer__append__C(
+           buffer, (java_lang_Character__forDigit__II(
+           hex_digit, (jint)16))));
+         }
+        }
+       }
+      }
+     }
+    }
+    else
+    {
+     jint i;
+     jint j;
+     i= (JCGO_CALL_FINALF(buffer) java_lang_StringBuffer__length__(
+      buffer));
+     for (;;)
+     {
+      jint digit;
+      digit= (gnu_java_math_MPN__divmod_1__IAIAII(
+       work, work, len, radix));
+      (java_lang_StringBuffer__append__C(
+       buffer, (java_lang_Character__forDigit__II(
+       digit, radix))));
+      while (len > 0 && JCGO_ARRAY_NZIACCESS(work, len - (jint)1) ==
+       0)
+      {
+       len--;
+      }
+      if (len == 0)
+      {
+       break;
+      }
+     }
+     if (neg)
+     {
+      (java_lang_StringBuffer__append__C(
+       buffer, (jchar)45/*'-'*/));
+     }
+     j= (java_lang_StringBuffer__length__(
+      buffer)) - (jint)1;
+     while (i < j)
+     {
+      jchar tmp;
+      tmp= (java_lang_StringBuffer__charAt__I(
+       buffer, i));
+      (java_lang_StringBuffer__setCharAt__IC(
+       buffer, i, (java_lang_StringBuffer__charAt__I(
+       buffer, j))));
+      (java_lang_StringBuffer__setCharAt__IC(
+       buffer, j, tmp));
+      i++;
+      j--;
+     }
+    }
+   }
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__this__Ls( java_math_BigInteger This, java_lang_String
+ val )
+{
+ {
+  (java_math_BigInteger__this__LsI((java_math_BigInteger)This, val,
+   (jint)10));
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_math_BigInteger CFASTCALL
+java_math_BigInteger__new__Ls( java_lang_String val )
+{
+ JCGO_CLINIT_TRIG(java_math_BigInteger__class);
+ return java_math_BigInteger__this__Ls(
+  (java_math_BigInteger)jcgo_newObject((jvtable)&java_math_BigInteger_methods),
+  val);
+}
+
+JCGO_NOSEP_STATIC java_math_BigInteger CFASTCALL
+java_math_BigInteger__valueOf__J( jlong val )
+{
+ {
+  java_math_BigInteger result;
+  jint i;
+  if (val >= java_math_BigInteger__minFixNum && val <= java_math_BigInteger__maxFixNum)
+  {
+   return ((java_math_BigInteger)JCGO_ARRAY_NZLACCESS(java_math_BigInteger__smallFixNums,
+    (jint)val - java_math_BigInteger__minFixNum));
+  }
+  i= (jint)val;
+  if ((jlong)i == val)
+  {
+   return (java_math_BigInteger__new__I(
+    i));
+  }
+  result= (java_math_BigInteger__alloc__I(
+   (jint)2));
+  JCGO_FIELD_NZACCESS(result, ival)= (jint)2;
+  JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(result, words), 0)= i;
+  JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(result, words), (jint)1)=
+   ((jint)JCGO_LSHR_F(val, (jint)32));
+  return result;
+ }
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_math_BigInteger__toString__( java_math_BigInteger This )
+{
+ {
+  return (java_math_BigInteger__toString__I(
+   This, (jint)10));
+ }
+}
+
+JCGO_NOSEP_STATIC java_lang_String CFASTCALL
+java_math_BigInteger__toString__I( java_math_BigInteger This, jint
+ radix )
+{
+ {
+  java_lang_StringBuffer buffer;
+  jint buf_size;
+  jint jcgo_rcvrI1;
+  struct java_lang_StringBuffer_s jcgo_stackobj1;
+  if (JCGO_FIELD_NZACCESS(This, words) == jnull)
+  {
+   return (java_lang_Integer__toString__II(
+    JCGO_FIELD_NZACCESS(This, ival), radix));
+  }
+  if (JCGO_FIELD_NZACCESS(This, ival) <= (jint)2)
+  {
+   return (java_lang_Long__toString__JI(
+    (java_math_BigInteger__longValue__(
+    This)), radix));
+  }
+  buf_size= (jcgo_rcvrI1= JCGO_FIELD_NZACCESS(This, ival), jcgo_rcvrI1 *
+   ((gnu_java_math_MPN__chars_per_word__I(
+   radix)) + (jint)1));
+  buffer= (java_lang_StringBuffer__this__I(
+   JCGO_STACKOBJ_NEW(jcgo_stackobj1, java_lang_StringBuffer_methods),
+   buf_size));
+  (java_math_BigInteger__format__IL8whtv(
+   This, buffer, radix));
+  return (java_lang_StringBuffer__toString__(
+   buffer));
+ }
+}
+
+JCGO_NOSEP_STATIC jlong CFASTCALL
+java_math_BigInteger__longValue__( java_math_BigInteger This )
+{
+ {
+  jlong jcgo_rcvrJ1;
+  if (JCGO_FIELD_NZACCESS(This, words) == jnull)
+  {
+   return (jlong)JCGO_FIELD_NZACCESS(This, ival);
+  }
+  if (JCGO_FIELD_NZACCESS(This, ival) == (jint)1)
+  {
+   return (jlong)(JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(This, words),
+    0));
+  }
+  return (jcgo_rcvrJ1= JCGO_LSHL_F((jlong)JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(This,
+   words), (jint)1), (jint)32), jcgo_rcvrJ1 + ((jlong)JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(This,
+   words), 0) & JLONG_C(0xffffffff)));
+ }
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_math_BigInteger__hashCode__( java_math_BigInteger This )
+{
+ {
+  jint jcgo_rcvrI1;
+  return JCGO_FIELD_NZACCESS(This, words) == jnull? JCGO_FIELD_NZACCESS(This,
+   ival) : (jcgo_rcvrI1= JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(This,
+   words), 0), jcgo_rcvrI1 + JCGO_ARRAY_IACCESS(JCGO_FIELD_NZACCESS(This,
+   words), JCGO_FIELD_NZACCESS(This, ival) - (jint)1));
+ }
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_math_BigInteger__equals__Lo( java_math_BigInteger This, java_lang_Object
+ obj )
+{
+ {
+  if (!jcgo_instanceOf0(OBJT_java_math_BigInteger, MAXT_java_math_BigInteger,
+   (jObject)obj))
+  {
+   return (jboolean)jfalse;
+  }
+  return (jboolean)(java_math_BigInteger__equals__L03o76L03o76(
+   This, (java_math_BigInteger)obj));
+ }
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_math_BigInteger__negate__IAIAI( jintArr dest, jintArr src, jint
+ len )
+{
+ {
+  jlong carry;
+  jboolean negative;
+  carry= (jlong)(jint)1;
+  negative= JCGO_ARRAY_IACCESS(src, len - (jint)1) < 0;
+  {
+   jint i;
+   i= 0;
+   for (; i < len; i++)
+   {
+    carry+= ((jlong)(~(JCGO_ARRAY_NZIACCESS(src, i))) & JLONG_C(0xffffffff));
+    JCGO_ARRAY_IACCESS(dest, i)= ((jint)carry);
+    carry= JCGO_LSHR_F(carry, (jint)32);
+   }
+  }
+  return (jboolean)(negative && JCGO_ARRAY_IACCESS(dest, len - (jint)1) <
+   0);
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_math_BigInteger__class__0( void )
+{
+ JCGO_CLINIT_BEGIN(java_math_BigInteger__class);
+ java_math_BigInteger__smallFixNums= (jObjectArr)jcgo_newArray(JCGO_CLASSREF_OF(java_math_BigInteger__class),
+  0, java_math_BigInteger__numFixNum);
+ {
+  {
+   jint i;
+   i= java_math_BigInteger__numFixNum;
+   for (; --i >= 0;)
+   {
+    jObject jcgo_rcvrL1;
+    jint jcgo_rcvrI1;
+    (jcgo_rcvrI1= i, jcgo_rcvrL1= (jObject)(java_math_BigInteger__new__I(
+     i + java_math_BigInteger__minFixNum)), *(java_math_BigInteger*)&JCGO_ARRAY_NZLACCESS(java_math_BigInteger__smallFixNums,
+     jcgo_rcvrI1)= (java_math_BigInteger)jcgo_rcvrL1);
+   }
+  }
+ }
+ java_math_BigInteger__ZERO= ((java_math_BigInteger)JCGO_ARRAY_NZLACCESS(java_math_BigInteger__smallFixNums,
+  (-java_math_BigInteger__minFixNum)));
+ JCGO_CLINIT_DONE(java_math_BigInteger__class);
+}
+
+JCGO_NOSEP_DATA CONST struct java_math_BigInteger_methods_s java_math_BigInteger_methods=
+{
+ JCGO_CLASSREF_OF(java_math_BigInteger__class),
+ JCGO_GCJDESCR_INIT(java_math_BigInteger_s, words)
+ OBJT_java_math_BigInteger,
+ (JCGO_OBJSIZE_T)sizeof(struct java_math_BigInteger_s),
+ NULL,
+ JCGO_CLINIT_INIT(java_math_BigInteger__class__0)
+ 0,
+ java_math_BigInteger__equals__Lo,
+ java_math_BigInteger__hashCode__,
+ java_math_BigInteger__toString__,
+ java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA struct java_math_BigInteger_class_s java_math_BigInteger__class
+ ATTRIBNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_math_BigInteger_methods),
+  JCGO_STRREF_OF(jcgo_string1_BigIntgr),
+  JCGO_CLASSREF_OF(java_lang_Number__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1c1
+ }
+};
+
+JCGO_NOSEP_GCDATA jObjectArr java_math_BigInteger__smallFixNums ATTRIBGCBSS=
+ jnull;
+
+JCGO_NOSEP_GCDATA java_math_BigInteger java_math_BigInteger__ZERO
+ ATTRIBGCBSS= jnull;
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype23_Object jcgo_array2_BigIntgr=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 20,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)109/*'m'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)103/*'g'*/, (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)103/*'g'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BigIntgr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BigIntgr),
+ 0, 20, (jint)0xc502bf18L
+};
+
+#ifdef CHKALL_java_math_BigInteger
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BigIntgr.h

@@ -0,0 +1,135 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+#define java_math_BigInteger__minFixNum (-(jint)100)
+
+#define java_math_BigInteger__maxFixNum (jint)1024
+
+#define java_math_BigInteger__numFixNum (java_math_BigInteger__maxFixNum - java_math_BigInteger__minFixNum + (jint)1)
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_math_BigInteger__void( java_math_BigInteger This );
+
+JCGO_NOSEP_STATIC java_math_BigInteger CFASTCALL
+java_math_BigInteger__this__LsI( java_math_BigInteger This, java_lang_String
+ val, jint radix );
+
+JCGO_NOSEP_STATIC java_math_BigInteger CFASTCALL
+java_math_BigInteger__this__I( java_math_BigInteger This, jint value
+ );
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__new__I( jint value );
+
+JCGO_NOSEP_STATIC java_math_BigInteger CFASTCALL
+java_math_BigInteger__this__( java_math_BigInteger This );
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__new__( void );
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__alloc__I( jint nwords );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_math_BigInteger__wordsNeeded__IAI( jintArr words, jint len );
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__make__IAI( jintArr words, jint len );
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__valueOf__BAIZI( jbyteArr digits, jint byte_len,
+ jint radix, jboolean negative );
+
+JCGO_NOSEP_FRWINL java_math_BigInteger CFASTCALL
+java_math_BigInteger__valueOf__LsI( java_lang_String s, jint radix
+ );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_math_BigInteger__equals__L03o76L03o76( java_math_BigInteger x,
+ java_math_BigInteger y );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_math_BigInteger__isNegative__( java_math_BigInteger This );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_math_BigInteger__getAbsolute__IA( java_math_BigInteger This,
+ jintArr words );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_math_BigInteger__format__IL8whtv( java_math_BigInteger This,
+ java_lang_StringBuffer buffer, jint radix );
+
+JCGO_NOSEP_INLINE java_math_BigInteger CFASTCALL
+java_math_BigInteger__this__Ls( java_math_BigInteger This, java_lang_String
+ val );
+JCGO_NOSEP_FRWINL java_math_BigInteger CFASTCALL
+java_math_BigInteger__new__Ls( java_lang_String val );
+
+JCGO_NOSEP_STATIC java_math_BigInteger CFASTCALL
+java_math_BigInteger__valueOf__J( jlong val );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_math_BigInteger__toString__( java_math_BigInteger This );
+
+JCGO_NOSEP_STATIC java_lang_String CFASTCALL
+java_math_BigInteger__toString__I( java_math_BigInteger This, jint
+ radix );
+
+JCGO_NOSEP_STATIC jlong CFASTCALL
+java_math_BigInteger__longValue__( java_math_BigInteger This );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_math_BigInteger__hashCode__( java_math_BigInteger This );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_math_BigInteger__equals__Lo( java_math_BigInteger This, java_lang_Object
+ obj );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_math_BigInteger__negate__IAIAI( jintArr dest, jintArr src, jint
+ len );
+
+struct java_math_BigInteger_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_math_BigInteger (CFASTCALL *jcgo_thisRtn)( java_math_BigInteger
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_math_BigInteger This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_math_BigInteger This );
+ java_lang_String (CFASTCALL *toString__)( java_math_BigInteger This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct java_math_BigInteger_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_math_BigInteger_methods_s java_math_BigInteger_methods;
+JCGO_SEP_EXTERN struct java_math_BigInteger_class_s java_math_BigInteger__class;
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_math_BigInteger__class__0( void );
+
+JCGO_SEP_GCEXTERN jObjectArr java_math_BigInteger__smallFixNums;
+JCGO_SEP_GCEXTERN java_math_BigInteger java_math_BigInteger__ZERO;
+
+struct java_math_BigInteger_s
+{
+ CONST struct java_math_BigInteger_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jintArr words;
+ jint ival;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype23_Object jcgo_array2_BigIntgr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BigIntgr;
+
+#endif

jcgo_Out/BndExcpt.c

@@ -0,0 +1,104 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_net_BindException
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_net_BindException CFASTCALL
+java_net_BindException__this__( java_net_BindException This )
+{
+ {
+  (java_net_SocketException__this__((java_net_SocketException)This));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_net_BindException CFASTCALL
+java_net_BindException__this__Ls( java_net_BindException This, java_lang_String
+ message )
+{
+ {
+  (java_net_SocketException__this__Ls((java_net_SocketException)This,
+   message));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_net_BindException CFASTCALL
+java_net_BindException__new__Ls( java_lang_String message )
+{
+ return java_net_BindException__this__Ls(
+  (java_net_BindException)jcgo_newObject((jvtable)&java_net_BindException_methods),
+  message);
+}
+
+JCGO_NOSEP_DATA CONST struct java_net_BindException_methods_s java_net_BindException_methods=
+{
+ JCGO_CLASSREF_OF(java_net_BindException__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_net_BindException,
+ (JCGO_OBJSIZE_T)sizeof(struct java_net_BindException_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ java_net_BindException__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Throwable__toString__,
+ java_lang_Object__finalize__,
+ java_lang_Throwable__getMessage__,
+ java_lang_Throwable__getCause__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_net_BindException_class_s
+ java_net_BindException__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_net_BindException_methods),
+  JCGO_STRREF_OF(jcgo_string1_BndExcpt),
+  JCGO_CLASSREF_OF(java_net_SocketException__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype44_GameShll jcgo_array2_BndExcpt=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 22,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)100/*'d'*/, (jbyte)(jchar)69/*'E'*/, (jbyte)(jchar)120/*'x'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)112/*'p'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BndExcpt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BndExcpt),
+ 0, 22, (jint)0x4ede8515L
+};
+
+#ifdef CHKALL_java_net_BindException
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BndExcpt.h

@@ -0,0 +1,59 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_net_BindException CFASTCALL
+java_net_BindException__this__( java_net_BindException This );
+
+JCGO_NOSEP_INLINE java_net_BindException CFASTCALL
+java_net_BindException__this__Ls( java_net_BindException This, java_lang_String
+ message );
+JCGO_NOSEP_INLINE java_net_BindException CFASTCALL
+java_net_BindException__new__Ls( java_lang_String message );
+
+struct java_net_BindException_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_net_BindException (CFASTCALL *jcgo_thisRtn)( java_net_BindException
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Throwable This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getMessage__)( java_lang_Throwable This
+  );
+ java_lang_Throwable (CFASTCALL *getCause__)( java_lang_Throwable This
+  );
+};
+
+struct java_net_BindException_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_net_BindException_methods_s java_net_BindException_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_net_BindException_class_s
+ java_net_BindException__class;
+
+struct java_net_BindException_s
+{
+ CONST struct java_net_BindException_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String detailMessage;
+ java_lang_Throwable cause;
+ jObjectArr stackTrace;
+ java_lang_VMThrowable vmState;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype44_GameShll jcgo_array2_BndExcpt;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BndExcpt;
+
+#endif

jcgo_Out/Boolean.c

@@ -0,0 +1,190 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_lang_Boolean
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_lang_Boolean CFASTCALL
+java_lang_Boolean__this__Z( java_lang_Boolean This, jboolean value
+ )
+{
+ {
+  ;
+  JCGO_FIELD_NZACCESS(This, value)= (jboolean)value;
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_lang_Boolean CFASTCALL
+java_lang_Boolean__new__Z( jboolean value )
+{
+ return java_lang_Boolean__this__Z(
+  (java_lang_Boolean)jcgo_newObject((jvtable)&java_lang_Boolean_methods),
+  value);
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_lang_Boolean__toString__Z( jboolean b )
+{
+ {
+  return b? JCGO_STRREF_OF(jcgo_string2_Boolean) : JCGO_STRREF_OF(jcgo_string3_Boolean);
+ }
+}
+
+JCGO_NOSEP_FRWINL jboolean CFASTCALL
+java_lang_Boolean__booleanValue__( java_lang_Boolean This )
+{
+ {
+  return (jboolean)JCGO_FIELD_NZACCESS(This, value);
+ }
+}
+
+JCGO_NOSEP_FRWINL java_lang_Boolean CFASTCALL
+java_lang_Boolean__valueOf__Z( jboolean b )
+{
+ JCGO_CLINIT_TRIG(java_lang_Boolean__class);
+ {
+  return b? java_lang_Boolean__TRUE0 : java_lang_Boolean__FALSE0;
+ }
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_lang_Boolean__toString__( java_lang_Boolean This )
+{
+ {
+  return (java_lang_Boolean__toString__Z(
+   (jboolean)JCGO_FIELD_NZACCESS(This, value)));
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_lang_Boolean__hashCode__( java_lang_Boolean This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, value)? (jint)1231 : (jint)1237;
+ }
+}
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_lang_Boolean__equals__Lo( java_lang_Boolean This, java_lang_Object
+ obj )
+{
+ {
+  return (jboolean)(jcgo_instanceOf0(OBJT_java_lang_Boolean, MAXT_java_lang_Boolean,
+   (jObject)obj) && JCGO_FIELD_NZACCESS(This, value) == JCGO_FIELD_NZACCESS(((java_lang_Boolean)obj),
+   value));
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_lang_Boolean__class__0( void )
+{
+ JCGO_CLINIT_BEGIN(java_lang_Boolean__class);
+ java_lang_Boolean__TRUE0= (java_lang_Boolean__new__Z(
+  (jboolean)jtrue));
+ java_lang_Boolean__FALSE0= (java_lang_Boolean__new__Z(
+  (jboolean)jfalse));
+ JCGO_CLINIT_DONE(java_lang_Boolean__class);
+}
+
+JCGO_NOSEP_DATA CONST struct java_lang_Boolean_methods_s java_lang_Boolean_methods=
+{
+ JCGO_CLASSREF_OF(java_lang_Boolean__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_lang_Boolean,
+ -(JCGO_OBJSIZE_T)sizeof(struct java_lang_Boolean_s),
+ NULL,
+ JCGO_CLINIT_INIT(java_lang_Boolean__class__0)
+ 0,
+ java_lang_Boolean__equals__Lo,
+ java_lang_Boolean__hashCode__,
+ java_lang_Boolean__toString__,
+ java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA struct java_lang_Boolean_class_s java_lang_Boolean__class
+ ATTRIBNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_lang_Boolean_methods),
+  JCGO_STRREF_OF(jcgo_string1_Boolean),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1d1
+ }
+};
+
+JCGO_NOSEP_GCDATA java_lang_Boolean java_lang_Boolean__TRUE0 ATTRIBGCBSS=
+ jnull;
+
+JCGO_NOSEP_GCDATA java_lang_Boolean java_lang_Boolean__FALSE0 ATTRIBGCBSS=
+ jnull;
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype492_Mdclnt jcgo_array4_Boolean=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 17,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)103/*'g'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype4_IntAddrs jcgo_array5_Boolean=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 4,
+ {
+  (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)101/*'e'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_Boolean
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array4_Boolean),
+ 0, 17, (jint)0x148d6054L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_Boolean
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array5_Boolean),
+ 0, 4, (jint)0x36758eL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_Boolean
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array8_Cnnctn),
+ 37, 5, (jint)0x5cb1923L
+};
+
+#ifdef CHKALL_java_lang_Boolean
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/Boolean.h

@@ -0,0 +1,78 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_lang_Boolean CFASTCALL
+java_lang_Boolean__this__Z( java_lang_Boolean This, jboolean value
+ );
+JCGO_NOSEP_FRWINL java_lang_Boolean CFASTCALL
+java_lang_Boolean__new__Z( jboolean value );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_lang_Boolean__toString__Z( jboolean b );
+
+JCGO_NOSEP_FRWINL jboolean CFASTCALL
+java_lang_Boolean__booleanValue__( java_lang_Boolean This );
+
+JCGO_NOSEP_FRWINL java_lang_Boolean CFASTCALL
+java_lang_Boolean__valueOf__Z( jboolean b );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_lang_Boolean__toString__( java_lang_Boolean This );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_lang_Boolean__hashCode__( java_lang_Boolean This );
+
+JCGO_NOSEP_INLINE jboolean CFASTCALL
+java_lang_Boolean__equals__Lo( java_lang_Boolean This, java_lang_Object
+ obj );
+
+struct java_lang_Boolean_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_lang_Boolean (CFASTCALL *jcgo_thisRtn)( java_lang_Boolean This
+  );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Boolean This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Boolean This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Boolean This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct java_lang_Boolean_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_lang_Boolean_methods_s java_lang_Boolean_methods;
+JCGO_SEP_EXTERN struct java_lang_Boolean_class_s java_lang_Boolean__class;
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_lang_Boolean__class__0( void );
+
+JCGO_SEP_GCEXTERN java_lang_Boolean java_lang_Boolean__TRUE0;
+JCGO_SEP_GCEXTERN java_lang_Boolean java_lang_Boolean__FALSE0;
+
+struct java_lang_Boolean_s
+{
+ CONST struct java_lang_Boolean_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jboolean value;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype492_Mdclnt jcgo_array4_Boolean;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype4_IntAddrs jcgo_array5_Boolean;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_Boolean;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_Boolean;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_Boolean;
+
+#endif

jcgo_Out/BscMpEnt.c

@@ -0,0 +1,155 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_util_AbstractMap
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE java_util_AbstractMap_BasicMapEntry CFASTCALL
+java_util_AbstractMap_BasicMapEntry__this__LoLo( java_util_AbstractMap_BasicMapEntry
+ This, java_lang_Object newKey, java_lang_Object newValue )
+{
+ {
+  ;
+  JCGO_FIELD_NZACCESS(This, key)= newKey;
+  JCGO_FIELD_NZACCESS(This, value)= newValue;
+ }
+ return This;
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractMap_BasicMapEntry__equals__Lo( java_util_AbstractMap_BasicMapEntry
+ This, java_lang_Object o )
+{
+ {
+  java_util_Map_Entry e;
+  jObject jcgo_rcvrL1;
+  if (jcgo_instanceOf0(OBJT_java_util_AbstractMap_BasicMapEntry, MAXT_java_util_AbstractMap_BasicMapEntry,
+   (jObject)o))
+  {
+   java_util_AbstractMap_BasicMapEntry e;
+   e= (java_util_AbstractMap_BasicMapEntry)o;
+   return (jboolean)((java_util_AbstractMap__equals__LoLo(
+    JCGO_FIELD_NZACCESS(This, key), JCGO_FIELD_NZACCESS(e, key))) &&
+    (java_util_AbstractMap__equals__LoLo(
+    JCGO_FIELD_NZACCESS(This, value), JCGO_FIELD_NZACCESS(e, value))));
+  }
+  if (!jcgo_instanceOf(OBJT_java_util_Map_Entry, MAXT_java_util_Map_Entry,
+   ~0, (jObject)o))
+  {
+   return (jboolean)jfalse;
+  }
+  e= (java_util_Map_Entry)o;
+  return (jboolean)((jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This,
+   key), java_util_AbstractMap__equals__LoLo(
+   (java_lang_Object)jcgo_rcvrL1, (JCGO_CALL_NZVFUNC(e)->getKey__(
+   e)))) && (jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This, value),
+   java_util_AbstractMap__equals__LoLo(
+   (java_lang_Object)jcgo_rcvrL1, (JCGO_CALL_NZVFUNC(e)->getValue__(
+   e)))));
+ }
+}
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_util_AbstractMap_BasicMapEntry__getKey__( java_util_AbstractMap_BasicMapEntry
+ This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, key);
+ }
+}
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_util_AbstractMap_BasicMapEntry__getValue__( java_util_AbstractMap_BasicMapEntry
+ This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, value);
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_AbstractMap_BasicMapEntry__hashCode__( java_util_AbstractMap_BasicMapEntry
+ This )
+{
+ {
+  jint jcgo_rcvrI1;
+  return (jcgo_rcvrI1= (java_util_AbstractMap__hashCode__Lo(
+   JCGO_FIELD_NZACCESS(This, key))), jcgo_rcvrI1 ^ (java_util_AbstractMap__hashCode__Lo(
+   JCGO_FIELD_NZACCESS(This, value))));
+ }
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_util_AbstractMap_BasicMapEntry__toString__( java_util_AbstractMap_BasicMapEntry
+ This )
+{
+ {
+  jObject jcgo_rcvrL1;
+  struct java_lang_StringBuilder_s jcgo_stackobj1;
+  return (jcgo_rcvrL1= (jObject)java_lang_StringBuilder__append__Ls(
+   java_lang_StringBuilder__append__Ls(
+   java_lang_StringBuilder__this__(
+   JCGO_STACKOBJ_NEW(jcgo_stackobj1, java_lang_StringBuilder_methods)),
+   (java_lang_String__valueOf__Lo(
+   JCGO_FIELD_NZACCESS(This, key)))), JCGO_STRREF_OF(jcgo_string2_HashEntr)),
+   java_lang_String__new__L5dy9e(
+   java_lang_StringBuilder__append__Ls(
+   (java_lang_StringBuilder)jcgo_rcvrL1, (java_lang_String__valueOf__Lo(
+   JCGO_FIELD_NZACCESS(This, value))))));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct java_util_AbstractMap_BasicMapEntry_methods_s
+ java_util_AbstractMap_BasicMapEntry_methods=
+{
+ JCGO_CLASSREF_OF(java_util_AbstractMap_BasicMapEntry__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_util_AbstractMap_BasicMapEntry,
+ (JCGO_OBJSIZE_T)sizeof(struct java_util_AbstractMap_BasicMapEntry_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_util_AbstractMap_BasicMapEntry__equals__Lo,
+ java_util_AbstractMap_BasicMapEntry__hashCode__,
+ java_util_AbstractMap_BasicMapEntry__toString__,
+ java_lang_Object__finalize__,
+ java_util_AbstractMap_BasicMapEntry__getKey__,
+ java_util_AbstractMap_BasicMapEntry__getValue__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_util_AbstractMap_BasicMapEntry_class_s
+ java_util_AbstractMap_BasicMapEntry__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_util_AbstractMap_BasicMapEntry_methods),
+  JCGO_STRREF_OF(jcgo_string1_BscMpEnt),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_HashEntr)),
+  0x8
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BscMpEnt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array3_AbstrcMp),
+ 0, 35, (jint)0x68a57b9aL
+};
+
+#ifdef CHKALL_java_util_AbstractMap
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BscMpEnt.h

@@ -0,0 +1,73 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE java_util_AbstractMap_BasicMapEntry CFASTCALL
+java_util_AbstractMap_BasicMapEntry__this__LoLo( java_util_AbstractMap_BasicMapEntry
+ This, java_lang_Object newKey, java_lang_Object newValue );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_util_AbstractMap_BasicMapEntry__equals__Lo( java_util_AbstractMap_BasicMapEntry
+ This, java_lang_Object o );
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_util_AbstractMap_BasicMapEntry__getKey__( java_util_AbstractMap_BasicMapEntry
+ This );
+
+JCGO_NOSEP_INLINE java_lang_Object CFASTCALL
+java_util_AbstractMap_BasicMapEntry__getValue__( java_util_AbstractMap_BasicMapEntry
+ This );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_util_AbstractMap_BasicMapEntry__hashCode__( java_util_AbstractMap_BasicMapEntry
+ This );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_util_AbstractMap_BasicMapEntry__toString__( java_util_AbstractMap_BasicMapEntry
+ This );
+
+struct java_util_AbstractMap_BasicMapEntry_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_util_AbstractMap_BasicMapEntry (CFASTCALL *jcgo_thisRtn)( java_util_AbstractMap_BasicMapEntry
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_util_AbstractMap_BasicMapEntry
+  This, java_lang_Object o );
+ jint (CFASTCALL *hashCode__)( java_util_AbstractMap_BasicMapEntry
+  This );
+ java_lang_String (CFASTCALL *toString__)( java_util_AbstractMap_BasicMapEntry
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_Object (CFASTCALL *getKey__)( java_util_AbstractMap_BasicMapEntry
+  This );
+ java_lang_Object (CFASTCALL *getValue__)( java_util_AbstractMap_BasicMapEntry
+  This );
+};
+
+struct java_util_AbstractMap_BasicMapEntry_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_util_AbstractMap_BasicMapEntry_methods_s
+ java_util_AbstractMap_BasicMapEntry_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_util_AbstractMap_BasicMapEntry_class_s
+ java_util_AbstractMap_BasicMapEntry__class;
+
+struct java_util_AbstractMap_BasicMapEntry_s
+{
+ CONST struct java_util_AbstractMap_BasicMapEntry_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_Object key;
+ java_lang_Object value;
+};
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BscMpEnt;
+
+#endif

jcgo_Out/BscPrmss.c

@@ -0,0 +1,151 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_security_BasicPermission
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_security_BasicPermission CFASTCALL
+java_security_BasicPermission__this__Ls( java_security_BasicPermission
+ This, java_lang_String name )
+{
+ {
+  (java_security_Permission__this__Ls((java_security_Permission)This,
+   name));
+  if ((JCGO_CALL_FINALF(name) java_lang_String__equals__Lo(
+   name, (java_lang_Object)JCGO_STRREF_OF(jcgo_string3_String6D))))
+  {
+   JCGO_THROW_EXC((java_lang_IllegalArgumentException__new__Ls(
+    JCGO_STRREF_OF(jcgo_string2_BscPrmss))));
+  }
+ }
+ return This;
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_security_BasicPermission__equals__Lo( java_security_BasicPermission
+ This, java_lang_Object obj )
+{
+ {
+  jObject jcgo_rcvrL1;
+  return (jboolean)(obj == (java_lang_Object)This || (jcgo_instanceOf0(OBJT_java_security_BasicPermission,
+   MAXT_java_security_BasicPermission, (jObject)obj) && (jcgo_rcvrL1=
+   (jObject)(java_lang_Object__getClass__(
+   obj)), (java_lang_Class)jcgo_rcvrL1 == (java_lang_Object__getClass__(
+   (java_lang_Object)This))) && (jcgo_rcvrL1= (jObject)(java_security_Permission__getName__(
+   (java_security_Permission)This)), JCGO_CALL_FINALF((java_lang_String)jcgo_rcvrL1)
+   java_lang_String__equals__Lo(
+   (java_lang_String)jcgo_rcvrL1, (java_lang_Object)(java_security_Permission__getName__(
+   (java_security_Permission)((java_security_BasicPermission)obj)))))));
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_security_BasicPermission__hashCode__( java_security_BasicPermission
+ This )
+{
+ {
+  jObject jcgo_rcvrL1;
+  return (jcgo_rcvrL1= (jObject)(java_security_Permission__getName__(
+   (java_security_Permission)This)), JCGO_CALL_FINALF((java_lang_String)jcgo_rcvrL1)
+   java_lang_String__hashCode__(
+   (java_lang_String)jcgo_rcvrL1));
+ }
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_security_BasicPermission__getActions__( java_security_BasicPermission
+ This )
+{
+ {
+  return JCGO_STRREF_OF(jcgo_string3_String6D);
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_security_BasicPermission_methods=
+{
+ JCGO_CLASSREF_OF(java_security_BasicPermission__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_security_BasicPermission,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_security_BasicPermission_class_s
+ java_security_BasicPermission__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_security_BasicPermission_methods),
+  JCGO_STRREF_OF(jcgo_string1_BscPrmss),
+  JCGO_CLASSREF_OF(java_security_Permission__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype86_GmCnnctn jcgo_array3_BscPrmss=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 29,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)115/*'s'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)66/*'B'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)80/*'P'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)109/*'m'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype32_GameShll jcgo_array4_BscPrmss=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 10,
+ {
+  (jbyte)(jchar)69/*'E'*/, (jbyte)(jchar)109/*'m'*/, (jbyte)(jchar)112/*'p'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)32/*' '*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)109/*'m'*/,
+   (jbyte)(jchar)101/*'e'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BscPrmss
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array3_BscPrmss),
+ 0, 29, (jint)0xafda981bL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_BscPrmss
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array4_BscPrmss),
+ 0, 10, (jint)0x3436099eL
+};
+
+#ifdef CHKALL_java_security_BasicPermission
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BscPrmss.h

@@ -0,0 +1,66 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_security_BasicPermission CFASTCALL
+java_security_BasicPermission__this__Ls( java_security_BasicPermission
+ This, java_lang_String name );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_security_BasicPermission__equals__Lo( java_security_BasicPermission
+ This, java_lang_Object obj );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_security_BasicPermission__hashCode__( java_security_BasicPermission
+ This );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_security_BasicPermission__getActions__( java_security_BasicPermission
+ This );
+
+struct java_security_BasicPermission_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_security_BasicPermission (CFASTCALL *jcgo_thisRtn)( java_security_BasicPermission
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_security_BasicPermission This,
+  java_lang_Object obj );
+ jint (CFASTCALL *hashCode__)( java_security_BasicPermission This );
+ java_lang_String (CFASTCALL *toString__)( java_security_Permission
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *getActions__)( java_security_BasicPermission
+  This );
+};
+
+struct java_security_BasicPermission_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_security_BasicPermission_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_security_BasicPermission_class_s
+ java_security_BasicPermission__class;
+
+struct java_security_BasicPermission_s
+{
+ CONST struct java_security_BasicPermission_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String name;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype86_GmCnnctn jcgo_array3_BscPrmss;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype32_GameShll jcgo_array4_BscPrmss;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BscPrmss;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_BscPrmss;
+
+#endif

jcgo_Out/BtArInSt.c

@@ -0,0 +1,198 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_io_ByteArrayInputStream
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE java_io_ByteArrayInputStream CFASTCALL
+java_io_ByteArrayInputStream__this__BAII( java_io_ByteArrayInputStream
+ This, jbyteArr buffer, jint offset, jint length )
+{
+ {
+  (java_io_InputStream__this__((java_io_InputStream)This));
+  if (offset < 0 || length < 0 || offset > JCGO_ARRAY_LENGTH(buffer))
+  {
+   JCGO_THROW_EXC(java_lang_IllegalArgumentException__new__());
+  }
+  JCGO_FIELD_NZACCESS(This, buf)= buffer;
+  JCGO_FIELD_NZACCESS(This, count)= offset + length;
+  if (JCGO_FIELD_NZACCESS(This, count) > JCGO_ARRAY_LENGTH(JCGO_FIELD_NZACCESS(This,
+   buf)))
+  {
+   JCGO_FIELD_NZACCESS(This, count)= JCGO_ARRAY_LENGTH(JCGO_FIELD_NZACCESS(This,
+    buf));
+  }
+  JCGO_FIELD_NZACCESS(This, pos)= offset;
+  (void)JCGO_FIELD_NZACCESS(This, pos);
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_io_ByteArrayInputStream CFASTCALL
+java_io_ByteArrayInputStream__this__BA( java_io_ByteArrayInputStream
+ This, jbyteArr buffer )
+{
+ {
+  (java_io_ByteArrayInputStream__this__BAII((java_io_ByteArrayInputStream)This,
+   buffer, 0, JCGO_ARRAY_LENGTH(buffer)));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_io_ByteArrayInputStream CFASTCALL
+java_io_ByteArrayInputStream__new__BA( jbyteArr buffer )
+{
+ return java_io_ByteArrayInputStream__this__BA(
+  (java_io_ByteArrayInputStream)jcgo_newObject((jvtable)&java_io_ByteArrayInputStream_methods),
+  buffer);
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_io_ByteArrayInputStream__available__( java_io_ByteArrayInputStream
+ This )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  {
+   jint jcgo_retval= JCGO_FIELD_NZACCESS(This, count) - JCGO_FIELD_NZACCESS(This,
+    pos);
+#ifndef JCGO_SEHTRY
+   JCGO_SYNC_JUMPLEAVE(0);
+#endif
+   return jcgo_retval;
+  }
+ }
+ JCGO_SYNC_ENDUNREACH
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_ByteArrayInputStream__read__( java_io_ByteArrayInputStream
+ This )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  if (JCGO_FIELD_NZACCESS(This, pos) < JCGO_FIELD_NZACCESS(This, count))
+  {
+   jObject jcgo_rcvrL1;
+   {
+    jint jcgo_retval= ((jint)(jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This,
+     buf), JCGO_ARRAY_BACCESS((jbyteArr)jcgo_rcvrL1, JCGO_FIELD_NZACCESS(This,
+     pos)++))) & (jint)255;
+#ifndef JCGO_SEHTRY
+    JCGO_SYNC_JUMPLEAVE(0);
+#endif
+    return jcgo_retval;
+   }
+  }
+#ifndef JCGO_SEHTRY
+  JCGO_SYNC_JUMPLEAVE(0);
+#endif
+  return (-(jint)1);
+ }
+ JCGO_SYNC_ENDUNREACH
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_ByteArrayInputStream__read__BAII( java_io_ByteArrayInputStream
+ This, jbyteArr buffer, jint offset, jint length )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  jint numBytes;
+  if (JCGO_FIELD_NZACCESS(This, pos) >= JCGO_FIELD_NZACCESS(This, count))
+  {
+#ifndef JCGO_SEHTRY
+   JCGO_SYNC_JUMPLEAVE(0);
+#endif
+   return (-(jint)1);
+  }
+  numBytes= (java_lang_Math__min__II(
+   JCGO_FIELD_NZACCESS(This, count) - JCGO_FIELD_NZACCESS(This, pos),
+   length));
+  (java_lang_System__arraycopy__LoILoII(
+   (java_lang_Object)JCGO_FIELD_NZACCESS(This, buf), (java_lang_Object)buffer,
+   JCGO_FIELD_NZACCESS(This, pos), offset, numBytes));
+  JCGO_FIELD_NZACCESS(This, pos)+= numBytes;
+#ifndef JCGO_SEHTRY
+  JCGO_SYNC_JUMPLEAVE(0);
+#endif
+  return numBytes;
+ }
+ JCGO_SYNC_ENDUNREACH
+}
+
+JCGO_NOSEP_DATA CONST struct java_io_ByteArrayInputStream_methods_s
+ java_io_ByteArrayInputStream_methods=
+{
+ JCGO_CLASSREF_OF(java_io_ByteArrayInputStream__class),
+ JCGO_GCJDESCR_INIT(java_io_ByteArrayInputStream_s, buf)
+ OBJT_java_io_ByteArrayInputStream,
+ (JCGO_OBJSIZE_T)sizeof(struct java_io_ByteArrayInputStream_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Object__toString__,
+ java_lang_Object__finalize__,
+ java_io_ByteArrayInputStream__available__,
+ (void (CFASTCALL*)(java_io_InputStream))java_lang_Object__finalize__,
+ java_io_ByteArrayInputStream__read__,
+ java_io_ByteArrayInputStream__read__BAII
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_io_ByteArrayInputStream_class_s
+ java_io_ByteArrayInputStream__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_io_ByteArrayInputStream_methods),
+  JCGO_STRREF_OF(jcgo_string1_BtArInSt),
+  JCGO_CLASSREF_OF(java_io_InputStream__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype90_GmCnnctn jcgo_array2_BtArInSt=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 28,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)66/*'B'*/,
+   (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)73/*'I'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)83/*'S'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)109/*'m'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BtArInSt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BtArInSt),
+ 0, 28, (jint)0xb181c515L
+};
+
+#ifdef CHKALL_java_io_ByteArrayInputStream
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BtArInSt.h

@@ -0,0 +1,73 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE java_io_ByteArrayInputStream CFASTCALL
+java_io_ByteArrayInputStream__this__BAII( java_io_ByteArrayInputStream
+ This, jbyteArr buffer, jint offset, jint length );
+
+JCGO_NOSEP_INLINE java_io_ByteArrayInputStream CFASTCALL
+java_io_ByteArrayInputStream__this__BA( java_io_ByteArrayInputStream
+ This, jbyteArr buffer );
+JCGO_NOSEP_INLINE java_io_ByteArrayInputStream CFASTCALL
+java_io_ByteArrayInputStream__new__BA( jbyteArr buffer );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_io_ByteArrayInputStream__available__( java_io_ByteArrayInputStream
+ This );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_ByteArrayInputStream__read__( java_io_ByteArrayInputStream
+ This );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_io_ByteArrayInputStream__read__BAII( java_io_ByteArrayInputStream
+ This, jbyteArr buffer, jint offset, jint length );
+
+struct java_io_ByteArrayInputStream_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_io_ByteArrayInputStream (CFASTCALL *jcgo_thisRtn)( java_io_ByteArrayInputStream
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jint (CFASTCALL *available__)( java_io_ByteArrayInputStream This );
+ void (CFASTCALL *close__)( java_io_InputStream This );
+ jint (CFASTCALL *read__)( java_io_ByteArrayInputStream This );
+ jint (CFASTCALL *read__BAII)( java_io_ByteArrayInputStream This, jbyteArr
+  buffer, jint offset, jint length );
+};
+
+struct java_io_ByteArrayInputStream_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_io_ByteArrayInputStream_methods_s
+ java_io_ByteArrayInputStream_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_io_ByteArrayInputStream_class_s
+ java_io_ByteArrayInputStream__class;
+
+struct java_io_ByteArrayInputStream_s
+{
+ CONST struct java_io_ByteArrayInputStream_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ jbyteArr buf;
+ jint pos;
+ jint count;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype90_GmCnnctn jcgo_array2_BtArInSt;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BtArInSt;
+
+#endif

jcgo_Out/BtArOtSt.c

@@ -0,0 +1,197 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_io_ByteArrayOutputStream
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE java_io_ByteArrayOutputStream CFASTCALL
+java_io_ByteArrayOutputStream__this__I( java_io_ByteArrayOutputStream
+ This, jint size )
+{
+ {
+  (java_io_OutputStream__this__((java_io_OutputStream)This));
+  JCGO_FIELD_NZACCESS(This, buf)= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+   0, size);
+  JCGO_FIELD_NZACCESS(This, count)= 0;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_io_ByteArrayOutputStream__resize__I( java_io_ByteArrayOutputStream
+ This, jint add )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, count) + add > JCGO_ARRAY_LENGTH(JCGO_FIELD_NZACCESS(This,
+   buf)))
+  {
+   jbyteArr newbuf;
+   jint newlen;
+   newlen= JCGO_ARRAY_LENGTH(JCGO_FIELD_NZACCESS(This, buf)) * (jint)2;
+   if (JCGO_FIELD_NZACCESS(This, count) + add > newlen)
+   {
+    newlen= JCGO_FIELD_NZACCESS(This, count) + add;
+   }
+   newbuf= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte),
+    0, newlen);
+   (java_lang_System__arraycopy__LoILoII(
+    (java_lang_Object)JCGO_FIELD_NZACCESS(This, buf), (java_lang_Object)newbuf,
+    0, 0, JCGO_FIELD_NZACCESS(This, count)));
+   JCGO_FIELD_NZACCESS(This, buf)= newbuf;
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE java_io_ByteArrayOutputStream CFASTCALL
+java_io_ByteArrayOutputStream__this__( java_io_ByteArrayOutputStream
+ This )
+{
+ {
+  (java_io_ByteArrayOutputStream__this__I((java_io_ByteArrayOutputStream)This,
+   java_io_ByteArrayOutputStream__initial_buffer_size));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_io_ByteArrayOutputStream CFASTCALL
+java_io_ByteArrayOutputStream__new__( void )
+{
+ JCGO_CLINIT_TRIG(java_io_ByteArrayOutputStream__class);
+ return java_io_ByteArrayOutputStream__this__(
+  (java_io_ByteArrayOutputStream)jcgo_newObject((jvtable)&java_io_ByteArrayOutputStream_methods));
+}
+
+JCGO_NOSEP_INLINE jbyteArr CFASTCALL
+java_io_ByteArrayOutputStream__toByteArray__( java_io_ByteArrayOutputStream
+ This )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  jbyteArr ret;
+  ret= (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte), 0, JCGO_FIELD_NZACCESS(This,
+   count));
+  (java_lang_System__arraycopy__LoILoII(
+   (java_lang_Object)JCGO_FIELD_NZACCESS(This, buf), (java_lang_Object)ret,
+   0, 0, JCGO_FIELD_NZACCESS(This, count)));
+#ifndef JCGO_SEHTRY
+  JCGO_SYNC_JUMPLEAVE(0);
+#endif
+  return ret;
+ }
+ JCGO_SYNC_ENDUNREACH
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_io_ByteArrayOutputStream__toString__( java_io_ByteArrayOutputStream
+ This )
+{
+ {
+  return (java_lang_String__new__BAII(
+   JCGO_FIELD_NZACCESS(This, buf), 0, JCGO_FIELD_NZACCESS(This, count)));
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_ByteArrayOutputStream__write__BAII( java_io_ByteArrayOutputStream
+ This, jbyteArr buffer, jint offset, jint add )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  if (add >= 0)
+  {
+   (java_io_ByteArrayOutputStream__resize__I(
+    This, add));
+  }
+  (java_lang_System__arraycopy__LoILoII(
+   (java_lang_Object)buffer, (java_lang_Object)JCGO_FIELD_NZACCESS(This,
+   buf), offset, JCGO_FIELD_NZACCESS(This, count), add));
+  JCGO_FIELD_NZACCESS(This, count)+= add;
+ }
+ JCGO_SYNC_END
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_ByteArrayOutputStream__class__0( void )
+{
+ JCGO_CLINIT_BEGIN(java_io_ByteArrayOutputStream__class);
+ {
+  jint r;
+  r= (java_lang_Integer__intValue__(
+   (java_lang_Integer__getInteger__LsI(
+   JCGO_STRREF_OF(jcgo_string2_BtArOtSt), java_io_ByteArrayOutputStream__DEFAULT_INITIAL_BUFFER_SIZE))));
+  if (r <= 0)
+  {
+   r= java_io_ByteArrayOutputStream__DEFAULT_INITIAL_BUFFER_SIZE;
+  }
+  java_io_ByteArrayOutputStream__initial_buffer_size= r;
+ }
+ JCGO_CLINIT_DONE(java_io_ByteArrayOutputStream__class);
+}
+
+JCGO_NOSEP_DATA CONST struct java_io_ByteArrayOutputStream_methods_s
+ java_io_ByteArrayOutputStream_methods=
+{
+ JCGO_CLASSREF_OF(java_io_ByteArrayOutputStream__class),
+ JCGO_GCJDESCR_INIT(java_io_ByteArrayOutputStream_s, buf)
+ OBJT_java_io_ByteArrayOutputStream,
+ (JCGO_OBJSIZE_T)sizeof(struct java_io_ByteArrayOutputStream_s),
+ NULL,
+ JCGO_CLINIT_INIT(java_io_ByteArrayOutputStream__class__0)
+ java_io_ByteArrayOutputStream__this__,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_io_ByteArrayOutputStream__toString__,
+ java_lang_Object__finalize__,
+ java_io_ByteArrayOutputStream__write__BAII,
+ (void (CFASTCALL*)(java_io_OutputStream))java_lang_Object__finalize__,
+ (void (CFASTCALL*)(java_io_OutputStream))java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA struct java_io_ByteArrayOutputStream_class_s java_io_ByteArrayOutputStream__class
+ ATTRIBNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_io_ByteArrayOutputStream_methods),
+  JCGO_STRREF_OF(jcgo_string1_BtArOtSt),
+  JCGO_CLASSREF_OF(java_io_OutputStream__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1c1
+ }
+};
+
+JCGO_NOSEP_DATA jint java_io_ByteArrayOutputStream__initial_buffer_size=
+ (jint)0;
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BtArOtSt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array12_VMClass),
+ 4, 29, (jint)0xac524416L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_BtArOtSt
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array12_VMClass),
+ 0, 51, (jint)0x199fd56dL
+};
+
+#ifdef CHKALL_java_io_ByteArrayOutputStream
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BtArOtSt.h

@@ -0,0 +1,82 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+#define java_io_ByteArrayOutputStream__DEFAULT_INITIAL_BUFFER_SIZE (jint)32
+
+JCGO_NOSEP_INLINE java_io_ByteArrayOutputStream CFASTCALL
+java_io_ByteArrayOutputStream__this__I( java_io_ByteArrayOutputStream
+ This, jint size );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_io_ByteArrayOutputStream__resize__I( java_io_ByteArrayOutputStream
+ This, jint add );
+
+JCGO_NOSEP_INLINE java_io_ByteArrayOutputStream CFASTCALL
+java_io_ByteArrayOutputStream__this__( java_io_ByteArrayOutputStream
+ This );
+JCGO_NOSEP_INLINE java_io_ByteArrayOutputStream CFASTCALL
+java_io_ByteArrayOutputStream__new__( void );
+
+JCGO_NOSEP_INLINE jbyteArr CFASTCALL
+java_io_ByteArrayOutputStream__toByteArray__( java_io_ByteArrayOutputStream
+ This );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_io_ByteArrayOutputStream__toString__( java_io_ByteArrayOutputStream
+ This );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_ByteArrayOutputStream__write__BAII( java_io_ByteArrayOutputStream
+ This, jbyteArr buffer, jint offset, jint add );
+
+struct java_io_ByteArrayOutputStream_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_io_ByteArrayOutputStream (CFASTCALL *jcgo_thisRtn)( java_io_ByteArrayOutputStream
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_io_ByteArrayOutputStream
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ void (CFASTCALL *write__BAII)( java_io_ByteArrayOutputStream This,
+  jbyteArr buffer, jint offset, jint add );
+ void (CFASTCALL *flush__)( java_io_OutputStream This );
+ void (CFASTCALL *close__)( java_io_OutputStream This );
+};
+
+struct java_io_ByteArrayOutputStream_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_io_ByteArrayOutputStream_methods_s
+ java_io_ByteArrayOutputStream_methods;
+JCGO_SEP_EXTERN struct java_io_ByteArrayOutputStream_class_s java_io_ByteArrayOutputStream__class;
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_io_ByteArrayOutputStream__class__0( void );
+
+JCGO_SEP_EXTERN jint java_io_ByteArrayOutputStream__initial_buffer_size;
+
+struct java_io_ByteArrayOutputStream_s
+{
+ CONST struct java_io_ByteArrayOutputStream_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ jbyteArr buf;
+ jint count;
+};
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BtArOtSt;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_BtArOtSt;
+
+#endif

jcgo_Out/BtBffrIm.c

@@ -0,0 +1,214 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_ByteBufferImpl
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_FRWINL java_nio_ByteBufferImpl CFASTCALL
+java_nio_ByteBufferImpl__this__BAIIIIIZ( java_nio_ByteBufferImpl This,
+ jbyteArr buffer, jint offset, jint capacity, jint limit, jint position,
+ jint mark, jboolean readOnly )
+{
+ {
+  (java_nio_ByteBuffer__this__IIIIL8d4dvBAI((java_nio_ByteBuffer)This,
+   (java_lang_Object)jnull, buffer, capacity, limit, position, mark,
+   offset));
+  JCGO_FIELD_NZACCESS(This, readOnly)= (jboolean)readOnly;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_nio_ByteBufferImpl CFASTCALL
+java_nio_ByteBufferImpl__new__BAIIIIIZ( jbyteArr buffer, jint offset,
+ jint capacity, jint limit, jint position, jint mark, jboolean readOnly
+ )
+{
+ return java_nio_ByteBufferImpl__this__BAIIIIIZ(
+  (java_nio_ByteBufferImpl)jcgo_newObject((jvtable)&java_nio_ByteBufferImpl_methods),
+  buffer, offset, capacity, limit, position, mark, readOnly);
+}
+
+JCGO_NOSEP_FRWINL jboolean CFASTCALL
+java_nio_ByteBufferImpl__isReadOnly__( java_nio_ByteBufferImpl This
+ )
+{
+ {
+  return (jboolean)JCGO_FIELD_NZACCESS(This, readOnly);
+ }
+}
+
+JCGO_NOSEP_STATIC jbyte CFASTCALL
+java_nio_ByteBufferImpl__get__( java_nio_ByteBufferImpl This )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, pos) >= JCGO_FIELD_NZACCESS(This, limit))
+  {
+   JCGO_THROW_EXC(java_nio_BufferUnderflowException__new__());
+  }
+  return JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This, backing_buffer),
+   (JCGO_FIELD_NZACCESS(This, pos)++) + JCGO_FIELD_NZACCESS(This, array_offset));
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBufferImpl__get__BAII( java_nio_ByteBufferImpl This,
+ jbyteArr dst, jint offset, jint length )
+{
+ {
+  (java_nio_Buffer__checkArraySize__III(
+   JCGO_ARRAY_LENGTH(dst), offset, length));
+  if ((JCGO_FIELD_NZACCESS(This, limit) - JCGO_FIELD_NZACCESS(This,
+   pos)) < length)
+  {
+   JCGO_THROW_EXC(java_nio_BufferUnderflowException__new__());
+  }
+  (java_lang_System__arraycopy__LoILoII(
+   (java_lang_Object)JCGO_FIELD_NZACCESS(This, backing_buffer), (java_lang_Object)dst,
+   JCGO_FIELD_NZACCESS(This, pos) + JCGO_FIELD_NZACCESS(This, array_offset),
+   offset, length));
+  JCGO_FIELD_NZACCESS(This, pos)+= length;
+  return (java_nio_ByteBuffer)This;
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBufferImpl__put__BAII( java_nio_ByteBufferImpl This,
+ jbyteArr src, jint offset, jint length )
+{
+ {
+  if ((JCGO_FIELD_NZACCESS(This, limit) - JCGO_FIELD_NZACCESS(This,
+   pos)) < length)
+  {
+   JCGO_THROW_EXC(java_nio_BufferOverflowException__new__());
+  }
+  (java_nio_Buffer__checkArraySize__III(
+   JCGO_ARRAY_LENGTH(src), offset, length));
+  (java_lang_System__arraycopy__LoILoII(
+   (java_lang_Object)src, (java_lang_Object)JCGO_FIELD_NZACCESS(This,
+   backing_buffer), offset, JCGO_FIELD_NZACCESS(This, pos) + JCGO_FIELD_NZACCESS(This,
+   array_offset), length));
+  JCGO_FIELD_NZACCESS(This, pos)+= length;
+  return (java_nio_ByteBuffer)This;
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBufferImpl__put__B( java_nio_ByteBufferImpl This, jbyte
+ value )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, readOnly))
+  {
+   JCGO_THROW_EXC(java_nio_ReadOnlyBufferException__new__());
+  }
+  if (JCGO_FIELD_NZACCESS(This, pos) >= JCGO_FIELD_NZACCESS(This, limit))
+  {
+   JCGO_THROW_EXC(java_nio_BufferOverflowException__new__());
+  }
+  JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This, backing_buffer), (JCGO_FIELD_NZACCESS(This,
+   pos)++) + JCGO_FIELD_NZACCESS(This, array_offset))= value;
+  return (java_nio_ByteBuffer)This;
+ }
+}
+
+JCGO_NOSEP_STATIC jbyte CFASTCALL
+java_nio_ByteBufferImpl__get__I( java_nio_ByteBufferImpl This, jint
+ index )
+{
+ {
+  (java_nio_Buffer__checkIndex__I(
+   (java_nio_Buffer)This, index));
+  return JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This, backing_buffer),
+   index + JCGO_FIELD_NZACCESS(This, array_offset));
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBufferImpl__putChar__C( java_nio_ByteBufferImpl This,
+ jchar value )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, readOnly))
+  {
+   JCGO_THROW_EXC(java_nio_ReadOnlyBufferException__new__());
+  }
+  if ((JCGO_FIELD_NZACCESS(This, limit) - JCGO_FIELD_NZACCESS(This,
+   pos)) < (jint)2)
+  {
+   JCGO_THROW_EXC(java_nio_BufferOverflowException__new__());
+  }
+  if (JCGO_FIELD_NZACCESS(This, endian) == JCGO_CLINIT_VARACC(java_nio_ByteOrder__class,
+   java_nio_ByteOrder__LITTLE_ENDIAN0))
+  {
+   JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This, backing_buffer), (JCGO_FIELD_NZACCESS(This,
+    pos)++) + JCGO_FIELD_NZACCESS(This, array_offset))= ((jbyte)(value &
+    (jint)255));
+   JCGO_ARRAY_NZBACCESS(JCGO_FIELD_NZACCESS(This, backing_buffer),
+    (JCGO_FIELD_NZACCESS(This, pos)++) + JCGO_FIELD_NZACCESS(This,
+    array_offset))= ((jbyte)JCGO_SHR_F(value, (jint)8));
+  }
+  else
+  {
+   JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This, backing_buffer), (JCGO_FIELD_NZACCESS(This,
+    pos)++) + JCGO_FIELD_NZACCESS(This, array_offset))= ((jbyte)JCGO_SHR_F(value,
+    (jint)8));
+   JCGO_ARRAY_NZBACCESS(JCGO_FIELD_NZACCESS(This, backing_buffer),
+    (JCGO_FIELD_NZACCESS(This, pos)++) + JCGO_FIELD_NZACCESS(This,
+    array_offset))= ((jbyte)(value & (jint)255));
+  }
+  return (java_nio_ByteBuffer)This;
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct java_nio_ByteBufferImpl_methods_s java_nio_ByteBufferImpl_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_ByteBufferImpl__class),
+ JCGO_GCJDESCR_INIT(java_nio_ByteBufferImpl_s, backing_buffer)
+ OBJT_java_nio_ByteBufferImpl,
+ (JCGO_OBJSIZE_T)sizeof(struct java_nio_ByteBufferImpl_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_nio_ByteBuffer__equals__Lo,
+ java_nio_ByteBuffer__hashCode__,
+ java_nio_ByteBuffer__toString__,
+ java_lang_Object__finalize__,
+ java_nio_ByteBufferImpl__isReadOnly__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_ByteBufferImpl_class_s
+ java_nio_ByteBufferImpl__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_ByteBufferImpl_methods),
+  JCGO_STRREF_OF(jcgo_string1_BtBffrIm),
+  JCGO_CLASSREF_OF(java_nio_ByteBuffer__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x10
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BtBffrIm
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array6_ByteBffr),
+ 0, 23, (jint)0xd2ef4c2eL
+};
+
+#ifdef CHKALL_java_nio_ByteBufferImpl
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BtBffrIm.h

@@ -0,0 +1,86 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_FRWINL java_nio_ByteBufferImpl CFASTCALL
+java_nio_ByteBufferImpl__this__BAIIIIIZ( java_nio_ByteBufferImpl This,
+ jbyteArr buffer, jint offset, jint capacity, jint limit, jint position,
+ jint mark, jboolean readOnly );
+JCGO_NOSEP_INLINE java_nio_ByteBufferImpl CFASTCALL
+java_nio_ByteBufferImpl__new__BAIIIIIZ( jbyteArr buffer, jint offset,
+ jint capacity, jint limit, jint position, jint mark, jboolean readOnly
+ );
+
+JCGO_NOSEP_FRWINL jboolean CFASTCALL
+java_nio_ByteBufferImpl__isReadOnly__( java_nio_ByteBufferImpl This
+ );
+
+JCGO_NOSEP_STATIC jbyte CFASTCALL
+java_nio_ByteBufferImpl__get__( java_nio_ByteBufferImpl This );
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBufferImpl__get__BAII( java_nio_ByteBufferImpl This,
+ jbyteArr dst, jint offset, jint length );
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBufferImpl__put__BAII( java_nio_ByteBufferImpl This,
+ jbyteArr src, jint offset, jint length );
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBufferImpl__put__B( java_nio_ByteBufferImpl This, jbyte
+ value );
+
+JCGO_NOSEP_STATIC jbyte CFASTCALL
+java_nio_ByteBufferImpl__get__I( java_nio_ByteBufferImpl This, jint
+ index );
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBufferImpl__putChar__C( java_nio_ByteBufferImpl This,
+ jchar value );
+
+struct java_nio_ByteBufferImpl_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_ByteBufferImpl (CFASTCALL *jcgo_thisRtn)( java_nio_ByteBufferImpl
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_nio_ByteBuffer This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_nio_ByteBuffer This );
+ java_lang_String (CFASTCALL *toString__)( java_nio_ByteBuffer This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *isReadOnly__)( java_nio_ByteBufferImpl This );
+};
+
+struct java_nio_ByteBufferImpl_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_nio_ByteBufferImpl_methods_s java_nio_ByteBufferImpl_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_ByteBufferImpl_class_s
+ java_nio_ByteBufferImpl__class;
+
+struct java_nio_ByteBufferImpl_s
+{
+ CONST struct java_nio_ByteBufferImpl_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ jint cap;
+ jint limit;
+ jint pos;
+ jint mark;
+ java_nio_ByteOrder endian;
+ jbyteArr backing_buffer;
+ jint array_offset;
+ jboolean readOnly;
+};
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BtBffrIm;
+
+#endif

jcgo_Out/BtChrst.c

@@ -0,0 +1,116 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_gnu_java_nio_charset_ByteCharset
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE gnu_java_nio_charset_ByteCharset CFASTCALL
+gnu_java_nio_charset_ByteCharset__this__LsLsA( gnu_java_nio_charset_ByteCharset
+ This, java_lang_String canonicalName, jObjectArr aliases )
+{
+ {
+  (java_nio_charset_Charset__this__LsLsA((java_nio_charset_Charset)This,
+   canonicalName, aliases));
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE jcharArr CFASTCALL
+gnu_java_nio_charset_ByteCharset__getLookupTable__( gnu_java_nio_charset_ByteCharset
+ This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, lookupTable);
+ }
+}
+
+JCGO_NOSEP_INLINE java_nio_charset_CharsetDecoder CFASTCALL
+gnu_java_nio_charset_ByteCharset__newDecoder__( gnu_java_nio_charset_ByteCharset
+ This )
+{
+ {
+  return (java_nio_charset_CharsetDecoder)(gnu_java_nio_charset_ByteCharset_Decoder__new__L85ew7(
+   This));
+ }
+}
+
+JCGO_NOSEP_INLINE java_nio_charset_CharsetEncoder CFASTCALL
+gnu_java_nio_charset_ByteCharset__newEncoder__( gnu_java_nio_charset_ByteCharset
+ This )
+{
+ {
+  return (java_nio_charset_CharsetEncoder)(gnu_java_nio_charset_ByteCharset_Encoder__new__L85ew7(
+   This));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s gnu_java_nio_charset_ByteCharset_methods=
+{
+ JCGO_CLASSREF_OF(gnu_java_nio_charset_ByteCharset__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_gnu_java_nio_charset_ByteCharset,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct gnu_java_nio_charset_ByteCharset_class_s
+ gnu_java_nio_charset_ByteCharset__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&gnu_java_nio_charset_ByteCharset_methods),
+  JCGO_STRREF_OF(jcgo_string1_BtChrst),
+  JCGO_CLASSREF_OF(java_nio_charset_Charset__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x400
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype120_GmCnnctn jcgo_array2_BtChrst=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 40,
+ {
+  (jbyte)(jchar)103/*'g'*/, (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)118/*'v'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)115/*'s'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)67/*'C'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)115/*'s'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)36/*'$'*/,
+   (jbyte)(jchar)68/*'D'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)99/*'c'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)100/*'d'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)114/*'r'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BtChrst
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BtChrst),
+ 0, 32, (jint)0x37ec383cL
+};
+
+#ifdef CHKALL_gnu_java_nio_charset_ByteCharset
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BtChrst.h

@@ -0,0 +1,68 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+#define gnu_java_nio_charset_ByteCharset__NONE ((jchar)(jint)65533L)
+
+JCGO_NOSEP_INLINE gnu_java_nio_charset_ByteCharset CFASTCALL
+gnu_java_nio_charset_ByteCharset__this__LsLsA( gnu_java_nio_charset_ByteCharset
+ This, java_lang_String canonicalName, jObjectArr aliases );
+
+JCGO_NOSEP_INLINE jcharArr CFASTCALL
+gnu_java_nio_charset_ByteCharset__getLookupTable__( gnu_java_nio_charset_ByteCharset
+ This );
+
+JCGO_NOSEP_INLINE java_nio_charset_CharsetDecoder CFASTCALL
+gnu_java_nio_charset_ByteCharset__newDecoder__( gnu_java_nio_charset_ByteCharset
+ This );
+
+JCGO_NOSEP_INLINE java_nio_charset_CharsetEncoder CFASTCALL
+gnu_java_nio_charset_ByteCharset__newEncoder__( gnu_java_nio_charset_ByteCharset
+ This );
+
+struct gnu_java_nio_charset_ByteCharset_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ gnu_java_nio_charset_ByteCharset (CFASTCALL *jcgo_thisRtn)( gnu_java_nio_charset_ByteCharset
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_nio_charset_Charset This, java_lang_Object
+  ob );
+ jint (CFASTCALL *hashCode__)( java_nio_charset_Charset This );
+ java_lang_String (CFASTCALL *toString__)( java_nio_charset_Charset
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_nio_charset_CharsetDecoder (CFASTCALL *newDecoder__)( gnu_java_nio_charset_ByteCharset
+  This );
+ java_nio_charset_CharsetEncoder (CFASTCALL *newEncoder__)( gnu_java_nio_charset_ByteCharset
+  This );
+};
+
+struct gnu_java_nio_charset_ByteCharset_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s gnu_java_nio_charset_ByteCharset_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct gnu_java_nio_charset_ByteCharset_class_s
+ gnu_java_nio_charset_ByteCharset__class;
+
+struct gnu_java_nio_charset_ByteCharset_s
+{
+ CONST struct gnu_java_nio_charset_ByteCharset_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String canonicalName;
+ jObjectArr aliases;
+ jcharArr lookupTable;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype120_GmCnnctn jcgo_array2_BtChrst;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BtChrst;
+
+#endif

jcgo_Out/Buffer96.c

@@ -0,0 +1,117 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_Buffer
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC package_Buffer CFASTCALL
+package_Buffer__this__BA( package_Buffer This, jbyteArr buff )
+{
+ {
+  ;
+  JCGO_FIELD_NZACCESS(This, buffer)= buff;
+  JCGO_FIELD_NZACCESS(This, offset)= 0;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE package_Buffer CFASTCALL
+package_Buffer__new__BA( jbyteArr buff )
+{
+ return package_Buffer__this__BA(
+  (package_Buffer)jcgo_newObject((jvtable)&package_Buffer_methods),
+  buff);
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+package_Buffer__getUnsignedByte__( package_Buffer This )
+{
+ {
+  jObject jcgo_rcvrL1;
+  return (jint)((unsigned char)(jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This,
+   buffer), JCGO_ARRAY_BACCESS((jbyteArr)jcgo_rcvrL1, JCGO_FIELD_NZACCESS(This,
+   offset)++)));
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+package_Buffer__getUnsignedShort__( package_Buffer This )
+{
+ {
+  jint jcgo_rcvrI1;
+  JCGO_FIELD_NZACCESS(This, offset)+= (jint)2;
+  return (jcgo_rcvrI1= JCGO_SHL_F(((jint)((unsigned char)(JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This,
+   buffer), JCGO_FIELD_NZACCESS(This, offset) - (jint)2)))), (jint)8),
+   jcgo_rcvrI1 + ((jint)((unsigned char)(JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This,
+   buffer), JCGO_FIELD_NZACCESS(This, offset) - (jint)1)))));
+ }
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+package_Buffer__getUnsignedInt__( package_Buffer This )
+{
+ {
+  jint jcgo_rcvrI1;
+  JCGO_FIELD_NZACCESS(This, offset)+= (jint)4;
+  return (jcgo_rcvrI1= (jcgo_rcvrI1= (jcgo_rcvrI1= JCGO_SHL_F(((jint)((unsigned char)(JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This,
+   buffer), JCGO_FIELD_NZACCESS(This, offset) - (jint)4)))), (jint)24),
+   jcgo_rcvrI1 + JCGO_SHL_F(((jint)((unsigned char)(JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This,
+   buffer), JCGO_FIELD_NZACCESS(This, offset) - (jint)3)))), (jint)16)),
+   jcgo_rcvrI1 + JCGO_SHL_F(((jint)((unsigned char)(JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This,
+   buffer), JCGO_FIELD_NZACCESS(This, offset) - (jint)2)))), (jint)8)),
+   jcgo_rcvrI1 + ((jint)((unsigned char)(JCGO_ARRAY_BACCESS(JCGO_FIELD_NZACCESS(This,
+   buffer), JCGO_FIELD_NZACCESS(This, offset) - (jint)1)))));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct package_Buffer_methods_s package_Buffer_methods=
+{
+ JCGO_CLASSREF_OF(package_Buffer__class),
+ JCGO_GCJDESCR_INIT(package_Buffer_s, buffer)
+ OBJT_package_Buffer,
+ (JCGO_OBJSIZE_T)sizeof(struct package_Buffer_s),
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_lang_Object__toString__,
+ java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct package_Buffer_class_s package_Buffer__class
+ JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&package_Buffer_methods),
+  JCGO_STRREF_OF(jcgo_string1_Buffer96),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_Buffer96
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BffrInSt),
+ 8, 6, (jint)0x77408060L
+};
+
+#ifdef CHKALL_Buffer
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/Buffer96.h

@@ -0,0 +1,53 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC package_Buffer CFASTCALL
+package_Buffer__this__BA( package_Buffer This, jbyteArr buff );
+JCGO_NOSEP_INLINE package_Buffer CFASTCALL
+package_Buffer__new__BA( jbyteArr buff );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+package_Buffer__getUnsignedByte__( package_Buffer This );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+package_Buffer__getUnsignedShort__( package_Buffer This );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+package_Buffer__getUnsignedInt__( package_Buffer This );
+
+struct package_Buffer_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ package_Buffer (CFASTCALL *jcgo_thisRtn)( package_Buffer This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct package_Buffer_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct package_Buffer_methods_s package_Buffer_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct package_Buffer_class_s package_Buffer__class;
+
+struct package_Buffer_s
+{
+ CONST struct package_Buffer_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jbyteArr buffer;
+ jint offset;
+};
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_Buffer96;
+
+#endif

jcgo_Out/BufferBD.c

@@ -0,0 +1,271 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_Buffer
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE java_nio_Buffer CFASTCALL
+java_nio_Buffer__limit__I( java_nio_Buffer This, jint newLimit )
+{
+ {
+  if ((newLimit < 0) || (newLimit > JCGO_FIELD_NZACCESS(This, cap)))
+  {
+   JCGO_THROW_EXC(java_lang_IllegalArgumentException__new__());
+  }
+  if (newLimit < JCGO_FIELD_NZACCESS(This, mark))
+  {
+   JCGO_FIELD_NZACCESS(This, mark)= (-(jint)1);
+  }
+  if (JCGO_FIELD_NZACCESS(This, pos) > newLimit)
+  {
+   JCGO_FIELD_NZACCESS(This, pos)= newLimit;
+  }
+  JCGO_FIELD_NZACCESS(This, limit)= newLimit;
+  return This;
+ }
+}
+
+JCGO_NOSEP_FRWINL jint CFASTCALL
+java_nio_Buffer__remaining__( java_nio_Buffer This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, limit) - JCGO_FIELD_NZACCESS(This,
+   pos);
+ }
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_nio_Buffer__limit__( java_nio_Buffer This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, limit);
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_Buffer CFASTCALL
+java_nio_Buffer__this__IIIIL8d4dv( java_nio_Buffer This, java_lang_Object
+ address, jint capacity, jint limit, jint position, jint mark )
+{
+ {
+  ;
+  (void)address;
+  if (capacity < 0)
+  {
+   JCGO_THROW_EXC(java_lang_IllegalArgumentException__new__());
+  }
+  JCGO_FIELD_NZACCESS(This, cap)= capacity;
+  (java_nio_Buffer__limit__I(
+   This, limit));
+  (java_nio_Buffer__position__I(
+   This, position));
+  if (mark >= 0)
+  {
+   if (mark > JCGO_FIELD_NZACCESS(This, pos))
+   {
+    JCGO_THROW_EXC(java_lang_IllegalArgumentException__new__());
+   }
+   JCGO_FIELD_NZACCESS(This, mark)= mark;
+  }
+  else
+  {
+   JCGO_FIELD_NZACCESS(This, mark)= (-(jint)1);
+  }
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL jint CFASTCALL
+java_nio_Buffer__capacity__( java_nio_Buffer This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, cap);
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_Buffer CFASTCALL
+java_nio_Buffer__clear__( java_nio_Buffer This )
+{
+ {
+  JCGO_FIELD_NZACCESS(This, limit)= JCGO_FIELD_NZACCESS(This, cap);
+  JCGO_FIELD_NZACCESS(This, pos)= 0;
+  JCGO_FIELD_NZACCESS(This, mark)= (-(jint)1);
+  return This;
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_Buffer CFASTCALL
+java_nio_Buffer__flip__( java_nio_Buffer This )
+{
+ {
+  JCGO_FIELD_NZACCESS(This, limit)= JCGO_FIELD_NZACCESS(This, pos);
+  JCGO_FIELD_NZACCESS(This, pos)= 0;
+  JCGO_FIELD_NZACCESS(This, mark)= (-(jint)1);
+  return This;
+ }
+}
+
+JCGO_NOSEP_FRWINL jboolean CFASTCALL
+java_nio_Buffer__hasRemaining__( java_nio_Buffer This )
+{
+ {
+  return (jboolean)((java_nio_Buffer__remaining__(
+   This)) > 0);
+ }
+}
+
+JCGO_NOSEP_FRWINL jint CFASTCALL
+java_nio_Buffer__position__( java_nio_Buffer This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, pos);
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_Buffer CFASTCALL
+java_nio_Buffer__position__I( java_nio_Buffer This, jint newPosition
+ )
+{
+ {
+  if ((newPosition < 0) || (newPosition > JCGO_FIELD_NZACCESS(This,
+   limit)))
+  {
+   JCGO_THROW_EXC(java_lang_IllegalArgumentException__new__());
+  }
+  if (newPosition <= JCGO_FIELD_NZACCESS(This, mark))
+  {
+   JCGO_FIELD_NZACCESS(This, mark)= (-(jint)1);
+  }
+  JCGO_FIELD_NZACCESS(This, pos)= newPosition;
+  return This;
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_Buffer__checkForUnderflow__I( java_nio_Buffer This, jint
+ length )
+{
+ {
+  if ((java_nio_Buffer__remaining__(
+   This)) < length)
+  {
+   JCGO_THROW_EXC(java_nio_BufferUnderflowException__new__());
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_Buffer__checkForOverflow__I( java_nio_Buffer This, jint length
+ )
+{
+ {
+  if ((java_nio_Buffer__remaining__(
+   This)) < length)
+  {
+   JCGO_THROW_EXC(java_nio_BufferOverflowException__new__());
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_Buffer__checkIndex__I( java_nio_Buffer This, jint index )
+{
+ {
+  if (index < 0 || index >= (java_nio_Buffer__limit__(
+   This)))
+  {
+   JCGO_THROW_EXC(java_lang_IndexOutOfBoundsException__new__());
+  }
+ }
+}
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_Buffer__checkIfReadOnly__( java_nio_Buffer This )
+{
+ {
+  if ((JCGO_CALL_NZVFUNC(This)->isReadOnly__(
+   This)))
+  {
+   JCGO_THROW_EXC(java_nio_ReadOnlyBufferException__new__());
+  }
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_Buffer__checkArraySize__III( jint arraylength, jint offset,
+ jint length )
+{
+ {
+  if ((offset < 0) || (length < 0) || (arraylength < length + offset))
+  {
+   JCGO_THROW_EXC(java_lang_IndexOutOfBoundsException__new__());
+  }
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_nio_Buffer_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_Buffer__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_Buffer,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_Buffer_class_s java_nio_Buffer__class
+ JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_Buffer_methods),
+  JCGO_STRREF_OF(jcgo_string1_BufferBD),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype98_GmCnnctn jcgo_array2_BufferBD=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 32,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)102/*'f'*/,
+   (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)79/*'O'*/, (jbyte)(jchar)118/*'v'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)119/*'w'*/, (jbyte)(jchar)69/*'E'*/,
+   (jbyte)(jchar)120/*'x'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BufferBD
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array2_BufferBD),
+ 0, 15, (jint)0x3091e8c6L
+};
+
+#ifdef CHKALL_java_nio_Buffer
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/BufferBD.h

@@ -0,0 +1,94 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE java_nio_Buffer CFASTCALL
+java_nio_Buffer__limit__I( java_nio_Buffer This, jint newLimit );
+
+JCGO_NOSEP_FRWINL jint CFASTCALL
+java_nio_Buffer__remaining__( java_nio_Buffer This );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_nio_Buffer__limit__( java_nio_Buffer This );
+
+JCGO_NOSEP_STATIC java_nio_Buffer CFASTCALL
+java_nio_Buffer__this__IIIIL8d4dv( java_nio_Buffer This, java_lang_Object
+ address, jint capacity, jint limit, jint position, jint mark );
+
+JCGO_NOSEP_FRWINL jint CFASTCALL
+java_nio_Buffer__capacity__( java_nio_Buffer This );
+
+JCGO_NOSEP_STATIC java_nio_Buffer CFASTCALL
+java_nio_Buffer__clear__( java_nio_Buffer This );
+
+JCGO_NOSEP_STATIC java_nio_Buffer CFASTCALL
+java_nio_Buffer__flip__( java_nio_Buffer This );
+
+JCGO_NOSEP_FRWINL jboolean CFASTCALL
+java_nio_Buffer__hasRemaining__( java_nio_Buffer This );
+
+JCGO_NOSEP_FRWINL jint CFASTCALL
+java_nio_Buffer__position__( java_nio_Buffer This );
+
+JCGO_NOSEP_STATIC java_nio_Buffer CFASTCALL
+java_nio_Buffer__position__I( java_nio_Buffer This, jint newPosition
+ );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_Buffer__checkForUnderflow__I( java_nio_Buffer This, jint
+ length );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_Buffer__checkForOverflow__I( java_nio_Buffer This, jint length
+ );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_Buffer__checkIndex__I( java_nio_Buffer This, jint index );
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_Buffer__checkIfReadOnly__( java_nio_Buffer This );
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_Buffer__checkArraySize__III( jint arraylength, jint offset,
+ jint length );
+
+struct java_nio_Buffer_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_Buffer (CFASTCALL *jcgo_thisRtn)( java_nio_Buffer This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *isReadOnly__)( java_nio_Buffer This );
+};
+
+struct java_nio_Buffer_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_nio_Buffer_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_Buffer_class_s java_nio_Buffer__class;
+
+struct java_nio_Buffer_s
+{
+ CONST struct java_nio_Buffer_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jint cap;
+ jint limit;
+ jint pos;
+ jint mark;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype98_GmCnnctn jcgo_array2_BufferBD;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_BufferBD;
+
+#endif

jcgo_Out/ByteBffr.c

@@ -0,0 +1,401 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_ByteBuffer
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_ByteBuffer__void( java_nio_ByteBuffer This )
+{
+ JCGO_FIELD_NZACCESS(This, endian)= JCGO_CLINIT_VARACC(java_nio_ByteOrder__class,
+  java_nio_ByteOrder__BIG_ENDIAN0);
+}
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_nio_ByteBuffer__compareTo__Lo( java_nio_ByteBuffer This, java_lang_Object
+ obj )
+{
+ {
+  java_nio_ByteBuffer other;
+  jint num;
+  jint pos_this;
+  jint pos_other;
+  jint jcgo_rcvrI1;
+  other= (java_nio_ByteBuffer)JCGO_CAST_OBJECT0(OBJT_java_nio_ByteBufferImpl,
+   MAXT_java_nio_ByteBufferImpl, obj);
+  num= (jcgo_rcvrI1= (java_nio_Buffer__remaining__(
+   (java_nio_Buffer)This)), java_lang_Math__min__II(
+   jcgo_rcvrI1, (JCGO_CALL_FINALF(other) java_nio_Buffer__remaining__(
+   (java_nio_Buffer)other))));
+  pos_this= (java_nio_Buffer__position__(
+   (java_nio_Buffer)This));
+  pos_other= (java_nio_Buffer__position__(
+   (java_nio_Buffer)other));
+  {
+   jint count;
+   count= 0;
+   for (; count < num; count++)
+   {
+    jbyte a;
+    jbyte b;
+    a= (java_nio_ByteBufferImpl__get__I(
+     (java_nio_ByteBufferImpl)This, pos_this++));
+    b= (java_nio_ByteBufferImpl__get__I(
+     (java_nio_ByteBufferImpl)other, pos_other++));
+    if (a == b)
+    {
+     continue;
+    }
+    if (a < b)
+    {
+     return (-(jint)1);
+    }
+    return (jint)1;
+   }
+  }
+  return (jcgo_rcvrI1= (java_nio_Buffer__remaining__(
+   (java_nio_Buffer)This)), jcgo_rcvrI1 - (java_nio_Buffer__remaining__(
+   (java_nio_Buffer)other)));
+ }
+}
+
+JCGO_NOSEP_INLINE java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__this__IIIIL8d4dvBAI( java_nio_ByteBuffer This,
+ java_lang_Object address, jbyteArr backing_buffer, jint capacity,
+ jint limit, jint position, jint mark, jint array_offset )
+{
+ {
+  (java_nio_Buffer__this__IIIIL8d4dv((java_nio_Buffer)This, address,
+   capacity, limit, position, mark));
+  java_nio_ByteBuffer__void(This);
+  JCGO_FIELD_NZACCESS(This, backing_buffer)= backing_buffer;
+  JCGO_FIELD_NZACCESS(This, array_offset)= array_offset;
+ }
+ return This;
+}
+
+JCGO_NOSEP_INLINE java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__allocate__I( jint capacity )
+{
+ {
+  return (java_nio_ByteBuffer__wrap__BAII(
+   (jbyteArr)jcgo_newArray(JCGO_CORECLASS_FOR(OBJT_jbyte), 0, capacity),
+   0, capacity));
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__wrap__BAIIX( jbyteArr array_7w5, jint offset,
+ jint length, java_nio_ByteBufferImpl jcgo_stackparam )
+{
+ {
+  return (java_nio_ByteBuffer)(java_nio_ByteBufferImpl__this__BAIIIIIZ(
+   jcgo_stackparam, array_7w5, 0, JCGO_ARRAY_LENGTH(array_7w5), offset +
+   length, offset, (-(jint)1), (jboolean)jfalse));
+ }
+}
+
+JCGO_NOSEP_FRWINL java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__wrap__BAII( jbyteArr array_7w5, jint offset,
+ jint length )
+{
+ return java_nio_ByteBuffer__wrap__BAIIX(
+  array_7w5, offset, length, (java_nio_ByteBufferImpl)jcgo_newObject((jvtable)&java_nio_ByteBufferImpl_methods));
+}
+
+JCGO_NOSEP_INLINE java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__wrap__BA( jbyteArr array_7w5 )
+{
+ {
+  return (java_nio_ByteBuffer__wrap__BAII(
+   array_7w5, 0, JCGO_ARRAY_LENGTH(array_7w5)));
+ }
+}
+
+JCGO_NOSEP_FRWINL java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__get__BA( java_nio_ByteBuffer This, jbyteArr dst
+ )
+{
+ {
+  return (java_nio_ByteBufferImpl__get__BAII(
+   (java_nio_ByteBufferImpl)This, dst, 0, JCGO_ARRAY_LENGTH(dst)));
+ }
+}
+
+JCGO_NOSEP_INLINE java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__put__BA( java_nio_ByteBuffer This, jbyteArr src
+ )
+{
+ {
+  return (java_nio_ByteBufferImpl__put__BAII(
+   (java_nio_ByteBufferImpl)This, src, 0, JCGO_ARRAY_LENGTH(src)));
+ }
+}
+
+JCGO_NOSEP_FRWINL jboolean CFASTCALL
+java_nio_ByteBuffer__hasArray__( java_nio_ByteBuffer This )
+{
+ {
+  return (jboolean)(JCGO_FIELD_NZACCESS(This, backing_buffer) != jnull &&
+   !(java_nio_ByteBufferImpl__isReadOnly__(
+   (java_nio_ByteBufferImpl)This)));
+ }
+}
+
+JCGO_NOSEP_STATIC jbyteArr CFASTCALL
+java_nio_ByteBuffer__array__( java_nio_ByteBuffer This )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, backing_buffer) == jnull)
+  {
+   JCGO_THROW_EXC(java_lang_UnsupportedOperationException__new__());
+  }
+  (java_nio_Buffer__checkIfReadOnly__(
+   (java_nio_Buffer)This));
+  return JCGO_FIELD_NZACCESS(This, backing_buffer);
+ }
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_nio_ByteBuffer__arrayOffset__( java_nio_ByteBuffer This )
+{
+ {
+  if (JCGO_FIELD_NZACCESS(This, backing_buffer) == jnull)
+  {
+   JCGO_THROW_EXC(java_lang_UnsupportedOperationException__new__());
+  }
+  (java_nio_Buffer__checkIfReadOnly__(
+   (java_nio_Buffer)This));
+  return JCGO_FIELD_NZACCESS(This, array_offset);
+ }
+}
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_nio_ByteBuffer__hashCode__( java_nio_ByteBuffer This )
+{
+ {
+  jint hashCode;
+  jint multiplier;
+  hashCode= (java_nio_ByteBufferImpl__get__I(
+   (java_nio_ByteBufferImpl)This, (java_nio_Buffer__position__(
+   (java_nio_Buffer)This)))) + (jint)31;
+  multiplier= (jint)1;
+  {
+   jint i;
+   i= (java_nio_Buffer__position__(
+    (java_nio_Buffer)This)) + (jint)1;
+   for (; i < (java_nio_Buffer__limit__(
+    (java_nio_Buffer)This)); ++i)
+   {
+    multiplier*= (jint)31;
+    hashCode+= ((java_nio_ByteBufferImpl__get__I(
+     (java_nio_ByteBufferImpl)This, i)) + (jint)30) * multiplier;
+   }
+  }
+  return hashCode;
+ }
+}
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_nio_ByteBuffer__equals__Lo( java_nio_ByteBuffer This, java_lang_Object
+ obj )
+{
+ {
+  if (jcgo_instanceOf0(OBJT_java_nio_ByteBufferImpl, MAXT_java_nio_ByteBufferImpl,
+   (jObject)obj))
+  {
+   return (jboolean)((java_nio_ByteBuffer__compareTo__Lo(
+    This, (java_lang_Object)((java_nio_ByteBuffer)obj))) == 0);
+  }
+  return (jboolean)jfalse;
+ }
+}
+
+JCGO_NOSEP_INLINE java_nio_ByteOrder CFASTCALL
+java_nio_ByteBuffer__order__( java_nio_ByteBuffer This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, endian);
+ }
+}
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__order__L14v1d( java_nio_ByteBuffer This, java_nio_ByteOrder
+ endian )
+{
+ {
+  JCGO_FIELD_NZACCESS(This, endian)= endian;
+  return This;
+ }
+}
+
+JCGO_NOSEP_STATIC java_lang_String CFASTCALL
+java_nio_ByteBuffer__toString__( java_nio_ByteBuffer This )
+{
+ {
+  jObject jcgo_rcvrL1;
+  struct java_lang_StringBuilder_s jcgo_stackobj1;
+  struct java_lang_String_s jcgo_stackobj2;
+  struct java_lang_String_s jcgo_stackobj3;
+  struct java_lang_String_s jcgo_stackobj4;
+  return java_lang_String__new__L5dy9e(
+   java_lang_StringBuilder__append__Ls(
+   (jcgo_rcvrL1= (jObject)java_lang_StringBuilder__append__Ls(
+   (jcgo_rcvrL1= (jObject)java_lang_StringBuilder__append__Ls(
+   (jcgo_rcvrL1= (jObject)java_lang_StringBuilder__append__Ls(
+   java_lang_StringBuilder__append__Ls(
+   java_lang_StringBuilder__this__(
+   JCGO_STACKOBJ_NEW(jcgo_stackobj1, java_lang_StringBuilder_methods)),
+   (jcgo_rcvrL1= (jObject)(java_lang_Object__getClass__(
+   (java_lang_Object)This)), JCGO_CALL_FINALF((java_lang_Class)jcgo_rcvrL1)
+   java_lang_Class__getName__(
+   (java_lang_Class)jcgo_rcvrL1))), JCGO_STRREF_OF(jcgo_string2_ByteBffr)),
+   java_lang_StringBuilder__append__Ls(
+   (java_lang_StringBuilder)jcgo_rcvrL1, (java_lang_String__valueOf__IX(
+   (java_nio_Buffer__position__(
+   (java_nio_Buffer)This)), JCGO_STACKOBJ_NEW(jcgo_stackobj2, java_lang_String_methods))))),
+   JCGO_STRREF_OF(jcgo_string3_ByteBffr)), java_lang_StringBuilder__append__Ls(
+   (java_lang_StringBuilder)jcgo_rcvrL1, (java_lang_String__valueOf__IX(
+   (java_nio_Buffer__limit__(
+   (java_nio_Buffer)This)), JCGO_STACKOBJ_NEW(jcgo_stackobj3, java_lang_String_methods))))),
+   JCGO_STRREF_OF(jcgo_string4_ByteBffr)), java_lang_StringBuilder__append__Ls(
+   (java_lang_StringBuilder)jcgo_rcvrL1, (java_lang_String__valueOf__IX(
+   (java_nio_Buffer__capacity__(
+   (java_nio_Buffer)This)), JCGO_STACKOBJ_NEW(jcgo_stackobj4, java_lang_String_methods))))),
+   JCGO_STRREF_OF(jcgo_string5_ByteBffr)));
+ }
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_nio_ByteBuffer_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_ByteBuffer__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_ByteBuffer,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ 0
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_ByteBuffer_class_s
+ java_nio_ByteBuffer__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_ByteBuffer_methods),
+  JCGO_STRREF_OF(jcgo_string1_ByteBffr),
+  JCGO_CLASSREF_OF(java_nio_Buffer__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x401
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype91_GmCnnctn jcgo_array6_ByteBffr=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 23,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)117/*'u'*/,
+   (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)102/*'f'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)109/*'m'*/,
+   (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)108/*'l'*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype30_Object jcgo_array7_ByteBffr=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 5,
+ {
+  (jbyte)(jchar)91/*'['*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)61/*'='*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype30_Object jcgo_array8_ByteBffr=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 5,
+ {
+  (jbyte)(jchar)32/*' '*/, (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)109/*'m'*/, (jbyte)(jchar)61/*'='*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype30_Object jcgo_array9_ByteBffr=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 5,
+ {
+  (jbyte)(jchar)32/*' '*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)61/*'='*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ByteBffr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array6_ByteBffr),
+ 0, 19, (jint)0xdf609ceeL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_ByteBffr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array7_ByteBffr),
+ 0, 5, (jint)0x536f344L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_ByteBffr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array8_ByteBffr),
+ 0, 5, (jint)0x1f59fcdL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string4_ByteBffr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array9_ByteBffr),
+ 0, 5, (jint)0x1f16acbL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string5_ByteBffr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array49_GameShll),
+ 78, 1, (jint)0x5dL
+};
+
+#ifdef CHKALL_java_nio_ByteBuffer
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/ByteBffr.h

@@ -0,0 +1,123 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_INLINE void CFASTCALL
+java_nio_ByteBuffer__void( java_nio_ByteBuffer This );
+
+JCGO_NOSEP_INLINE jint CFASTCALL
+java_nio_ByteBuffer__compareTo__Lo( java_nio_ByteBuffer This, java_lang_Object
+ obj );
+
+JCGO_NOSEP_INLINE java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__this__IIIIL8d4dvBAI( java_nio_ByteBuffer This,
+ java_lang_Object address, jbyteArr backing_buffer, jint capacity,
+ jint limit, jint position, jint mark, jint array_offset );
+
+JCGO_NOSEP_INLINE java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__allocate__I( jint capacity );
+
+JCGO_NOSEP_FRWINL java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__wrap__BAII( jbyteArr array_7w5, jint offset,
+ jint length );
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__wrap__BAIIX( jbyteArr array_7w5, jint offset,
+ jint length, java_nio_ByteBufferImpl jcgo_stackparam );
+
+JCGO_NOSEP_INLINE java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__wrap__BA( jbyteArr array_7w5 );
+
+JCGO_NOSEP_FRWINL java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__get__BA( java_nio_ByteBuffer This, jbyteArr dst
+ );
+
+JCGO_NOSEP_INLINE java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__put__BA( java_nio_ByteBuffer This, jbyteArr src
+ );
+
+JCGO_NOSEP_FRWINL jboolean CFASTCALL
+java_nio_ByteBuffer__hasArray__( java_nio_ByteBuffer This );
+
+JCGO_NOSEP_STATIC jbyteArr CFASTCALL
+java_nio_ByteBuffer__array__( java_nio_ByteBuffer This );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_nio_ByteBuffer__arrayOffset__( java_nio_ByteBuffer This );
+
+JCGO_NOSEP_STATIC jint CFASTCALL
+java_nio_ByteBuffer__hashCode__( java_nio_ByteBuffer This );
+
+JCGO_NOSEP_STATIC jboolean CFASTCALL
+java_nio_ByteBuffer__equals__Lo( java_nio_ByteBuffer This, java_lang_Object
+ obj );
+
+JCGO_NOSEP_INLINE java_nio_ByteOrder CFASTCALL
+java_nio_ByteBuffer__order__( java_nio_ByteBuffer This );
+
+JCGO_NOSEP_STATIC java_nio_ByteBuffer CFASTCALL
+java_nio_ByteBuffer__order__L14v1d( java_nio_ByteBuffer This, java_nio_ByteOrder
+ endian );
+
+JCGO_NOSEP_STATIC java_lang_String CFASTCALL
+java_nio_ByteBuffer__toString__( java_nio_ByteBuffer This );
+
+struct java_nio_ByteBuffer_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_ByteBuffer (CFASTCALL *jcgo_thisRtn)( java_nio_ByteBuffer
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_nio_ByteBuffer This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_nio_ByteBuffer This );
+ java_lang_String (CFASTCALL *toString__)( java_nio_ByteBuffer This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ jboolean (CFASTCALL *isReadOnly__)( java_nio_Buffer This );
+};
+
+struct java_nio_ByteBuffer_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_nio_ByteBuffer_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_ByteBuffer_class_s
+ java_nio_ByteBuffer__class;
+
+struct java_nio_ByteBuffer_s
+{
+ CONST struct java_nio_ByteBuffer_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+ jint cap;
+ jint limit;
+ jint pos;
+ jint mark;
+ java_nio_ByteOrder endian;
+ jbyteArr backing_buffer;
+ jint array_offset;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype91_GmCnnctn jcgo_array6_ByteBffr;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype30_Object jcgo_array7_ByteBffr;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype30_Object jcgo_array8_ByteBffr;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype30_Object jcgo_array9_ByteBffr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ByteBffr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_ByteBffr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_ByteBffr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string4_ByteBffr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string5_ByteBffr;
+
+#endif

jcgo_Out/ByteOrdr.c

@@ -0,0 +1,157 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_ByteOrder
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_nio_ByteOrder CFASTCALL
+java_nio_ByteOrder__this__( java_nio_ByteOrder This )
+{
+ {
+  ;
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_nio_ByteOrder CFASTCALL
+java_nio_ByteOrder__new__( void )
+{
+ return java_nio_ByteOrder__this__(
+  (java_nio_ByteOrder)jcgo_newObject((jvtable)&java_nio_ByteOrder_methods));
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_nio_ByteOrder__toString__( java_nio_ByteOrder This )
+{
+ {
+  return This == java_nio_ByteOrder__BIG_ENDIAN0? JCGO_STRREF_OF(jcgo_string2_ByteOrdr) :
+   JCGO_STRREF_OF(jcgo_string3_ByteOrdr);
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_ByteOrder__class__0( void )
+{
+ JCGO_CLINIT_BEGIN(java_nio_ByteOrder__class);
+ java_nio_ByteOrder__BIG_ENDIAN0= java_nio_ByteOrder__new__();
+ java_nio_ByteOrder__LITTLE_ENDIAN0= java_nio_ByteOrder__new__();
+ JCGO_CLINIT_DONE(java_nio_ByteOrder__class);
+}
+
+JCGO_NOSEP_DATA CONST struct java_nio_ByteOrder_methods_s java_nio_ByteOrder_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_ByteOrder__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_ByteOrder,
+ -(JCGO_OBJSIZE_T)sizeof(struct java_nio_ByteOrder_s),
+ NULL,
+ JCGO_CLINIT_INIT(java_nio_ByteOrder__class__0)
+ 0,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_nio_ByteOrder__toString__,
+ java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA struct java_nio_ByteOrder_class_s java_nio_ByteOrder__class
+ ATTRIBNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_ByteOrder_methods),
+  JCGO_STRREF_OF(jcgo_string1_ByteOrdr),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1d1
+ }
+};
+
+JCGO_NOSEP_GCDATA java_nio_ByteOrder java_nio_ByteOrder__BIG_ENDIAN0
+ ATTRIBGCBSS= jnull;
+
+JCGO_NOSEP_GCDATA java_nio_ByteOrder java_nio_ByteOrder__LITTLE_ENDIAN0
+ ATTRIBGCBSS= jnull;
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype82_GmCnnctn jcgo_array4_ByteOrdr=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 18,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)121/*'y'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)79/*'O'*/, (jbyte)(jchar)114/*'r'*/,
+   (jbyte)(jchar)100/*'d'*/, (jbyte)(jchar)101/*'e'*/, (jbyte)(jchar)114/*'r'*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype32_GameShll jcgo_array5_ByteOrdr=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 10,
+ {
+  (jbyte)(jchar)66/*'B'*/, (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)71/*'G'*/,
+   (jbyte)(jchar)95/*'_'*/, (jbyte)(jchar)69/*'E'*/, (jbyte)(jchar)78/*'N'*/,
+   (jbyte)(jchar)68/*'D'*/, (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)65/*'A'*/,
+   (jbyte)(jchar)78/*'N'*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype30_GameShll jcgo_array6_ByteOrdr=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 13,
+ {
+  (jbyte)(jchar)76/*'L'*/, (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)84/*'T'*/,
+   (jbyte)(jchar)84/*'T'*/, (jbyte)(jchar)76/*'L'*/, (jbyte)(jchar)69/*'E'*/,
+   (jbyte)(jchar)95/*'_'*/, (jbyte)(jchar)69/*'E'*/, (jbyte)(jchar)78/*'N'*/,
+   (jbyte)(jchar)68/*'D'*/, (jbyte)(jchar)73/*'I'*/, (jbyte)(jchar)65/*'A'*/,
+   (jbyte)(jchar)78/*'N'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ByteOrdr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array4_ByteOrdr),
+ 0, 18, (jint)0xa4d1b0e0L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_ByteOrdr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array5_ByteOrdr),
+ 0, 10, (jint)0x2d7fcfdaL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_ByteOrdr
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array6_ByteOrdr),
+ 0, 13, (jint)0x234d7504L
+};
+
+#ifdef CHKALL_java_nio_ByteOrder
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/ByteOrdr.h

@@ -0,0 +1,63 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_nio_ByteOrder CFASTCALL
+java_nio_ByteOrder__this__( java_nio_ByteOrder This );
+JCGO_NOSEP_FRWINL java_nio_ByteOrder CFASTCALL
+java_nio_ByteOrder__new__( void );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_nio_ByteOrder__toString__( java_nio_ByteOrder This );
+
+struct java_nio_ByteOrder_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_ByteOrder (CFASTCALL *jcgo_thisRtn)( java_nio_ByteOrder This
+  );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_nio_ByteOrder This
+  );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct java_nio_ByteOrder_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_nio_ByteOrder_methods_s java_nio_ByteOrder_methods;
+JCGO_SEP_EXTERN struct java_nio_ByteOrder_class_s java_nio_ByteOrder__class;
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_ByteOrder__class__0( void );
+
+JCGO_SEP_GCEXTERN java_nio_ByteOrder java_nio_ByteOrder__BIG_ENDIAN0;
+JCGO_SEP_GCEXTERN java_nio_ByteOrder java_nio_ByteOrder__LITTLE_ENDIAN0;
+
+struct java_nio_ByteOrder_s
+{
+ CONST struct java_nio_ByteOrder_methods_s *JCGO_IMMFLD_CONST jcgo_methods;
+ JCGO_MON_DEFN
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype82_GmCnnctn jcgo_array4_ByteOrdr;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype32_GameShll jcgo_array5_ByteOrdr;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype30_GameShll jcgo_array6_ByteOrdr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_ByteOrdr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_ByteOrdr;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_ByteOrdr;
+
+#endif

jcgo_Out/CacheE78.c

@@ -0,0 +1,154 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_charset_CoderResult
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_nio_charset_CoderResult_Cache CFASTCALL
+java_nio_charset_CoderResult_Cache__this__( java_nio_charset_CoderResult_Cache
+ This )
+{
+ {
+  ;
+  JCGO_FIELD_NZACCESS(This, cache)= java_util_HashMap__new__();
+ }
+ return This;
+}
+
+JCGO_NOSEP_STATIC java_nio_charset_CoderResult CFASTCALL
+java_nio_charset_CoderResult_Cache__get__I( java_nio_charset_CoderResult_Cache
+ This, jint length )
+{
+ JCGO_SYNC_BLOCKSAFENZ(This)
+ {
+  java_lang_Integer len;
+  java_nio_charset_CoderResult cr;
+  java_lang_Object o;
+  jObject jcgo_rcvrL1;
+  if (length <= 0)
+  {
+   JCGO_THROW_EXC((java_lang_IllegalArgumentException__new__Ls(
+    JCGO_STRREF_OF(jcgo_string2_CacheE78))));
+  }
+  len= (java_lang_Integer__new__I(
+   length));
+  cr= (java_nio_charset_CoderResult)jnull;
+  if ((o= (jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This, cache),
+   JCGO_CALL_FINALF((java_util_HashMap)jcgo_rcvrL1) java_util_HashMap__get__Lo(
+   (java_util_HashMap)jcgo_rcvrL1, (java_lang_Object)len))) != jnull)
+  {
+   cr= (java_nio_charset_CoderResult)JCGO_CAST_OBJECT0(OBJT_java_nio_charset_CoderResult,
+    MAXT_java_nio_charset_CoderResult, (java_lang_ref_Reference__get__(
+    (java_lang_ref_Reference)((java_lang_ref_WeakReference)JCGO_CAST_OBJECT0(OBJT_java_lang_ref_WeakReference,
+    MAXT_java_lang_ref_WeakReference, o)))));
+  }
+  if (cr == jnull)
+  {
+   jObject jcgo_rcvrL1;
+   cr= (JCGO_CALL_NZVFUNC(This)->make__I(
+    This, length));
+   (jcgo_rcvrL1= (jObject)JCGO_FIELD_NZACCESS(This, cache), java_util_HashMap__put__LoLo(
+    (java_util_HashMap)jcgo_rcvrL1, (java_lang_Object)len, (java_lang_Object)(java_lang_ref_WeakReference__new__Lo(
+    (java_lang_Object)cr))));
+  }
+#ifndef JCGO_SEHTRY
+  JCGO_SYNC_JUMPLEAVE(0);
+#endif
+  return cr;
+ }
+ JCGO_SYNC_ENDUNREACH
+}
+
+JCGO_NOSEP_DATA CONST struct jcgo_methods_s java_nio_charset_CoderResult_Cache_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_charset_CoderResult_Cache__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_charset_CoderResult_Cache,
+ 0,
+ NULL,
+ JCGO_CLINIT_INIT(0)
+ (jObject (CFASTCALL*)(jObject))java_nio_charset_CoderResult_Cache__this__
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_nio_charset_CoderResult_Cache_class_s
+ java_nio_charset_CoderResult_Cache__class JCGO_THRD_ATTRNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_charset_CoderResult_Cache_methods),
+  JCGO_STRREF_OF(jcgo_string1_CacheE78),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x40a
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype87_GmCnnctn jcgo_array3_CacheE78=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 34,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)67/*'C'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)100/*'d'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)82/*'R'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)117/*'u'*/, (jbyte)(jchar)108/*'l'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)36/*'$'*/, (jbyte)(jchar)67/*'C'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/,
+   (jbyte)(jchar)101/*'e'*/
+ }
+};
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype42_GameShll jcgo_array4_CacheE78=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 19,
+ {
+  (jbyte)(jchar)78/*'N'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)45/*'-'*/, (jbyte)(jchar)112/*'p'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)118/*'v'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)32/*' '*/, (jbyte)(jchar)108/*'l'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)103/*'g'*/, (jbyte)(jchar)116/*'t'*/,
+   (jbyte)(jchar)104/*'h'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_CacheE78
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array3_CacheE78),
+ 0, 34, (jint)0xb08b1278L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_CacheE78
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array4_CacheE78),
+ 0, 19, (jint)0x18a5c7cdL
+};
+
+#ifdef CHKALL_java_nio_charset_CoderResult
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/CacheE78.h

@@ -0,0 +1,57 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_nio_charset_CoderResult_Cache CFASTCALL
+java_nio_charset_CoderResult_Cache__this__( java_nio_charset_CoderResult_Cache
+ This );
+
+JCGO_NOSEP_STATIC java_nio_charset_CoderResult CFASTCALL
+java_nio_charset_CoderResult_Cache__get__I( java_nio_charset_CoderResult_Cache
+ This, jint length );
+
+struct java_nio_charset_CoderResult_Cache_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_charset_CoderResult_Cache (CFASTCALL *jcgo_thisRtn)( java_nio_charset_CoderResult_Cache
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_lang_Object This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+ java_nio_charset_CoderResult (CFASTCALL *make__I)( java_nio_charset_CoderResult_Cache
+  This, jint length );
+};
+
+struct java_nio_charset_CoderResult_Cache_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct jcgo_methods_s java_nio_charset_CoderResult_Cache_methods;
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_nio_charset_CoderResult_Cache_class_s
+ java_nio_charset_CoderResult_Cache__class;
+
+struct java_nio_charset_CoderResult_Cache_s
+{
+ CONST struct java_nio_charset_CoderResult_Cache_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_util_HashMap cache;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype87_GmCnnctn jcgo_array3_CacheE78;
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype42_GameShll jcgo_array4_CacheE78;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_CacheE78;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_CacheE78;
+
+#endif

jcgo_Out/CdngErAc.c

@@ -0,0 +1,154 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_SEPARATED
+#define JCGO_116
+#include "jcgortl.h"
+#include "Main.h"
+#endif
+
+#ifdef JCGO_116
+
+#ifdef CHKALL_java_nio_charset_CodingErrorAction
+#include "jcgobchk.h"
+#endif
+
+JCGO_NOSEP_STATIC java_nio_charset_CodingErrorAction CFASTCALL
+java_nio_charset_CodingErrorAction__this__Ls( java_nio_charset_CodingErrorAction
+ This, java_lang_String name )
+{
+ {
+  ;
+  JCGO_FIELD_NZACCESS(This, name)= name;
+ }
+ return This;
+}
+
+JCGO_NOSEP_FRWINL java_nio_charset_CodingErrorAction CFASTCALL
+java_nio_charset_CodingErrorAction__new__Ls( java_lang_String name
+ )
+{
+ return java_nio_charset_CodingErrorAction__this__Ls(
+  (java_nio_charset_CodingErrorAction)jcgo_newObject((jvtable)&java_nio_charset_CodingErrorAction_methods),
+  name);
+}
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_nio_charset_CodingErrorAction__toString__( java_nio_charset_CodingErrorAction
+ This )
+{
+ {
+  return JCGO_FIELD_NZACCESS(This, name);
+ }
+}
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_charset_CodingErrorAction__class__0( void )
+{
+ JCGO_CLINIT_BEGIN(java_nio_charset_CodingErrorAction__class);
+ (void)((java_nio_charset_CodingErrorAction__new__Ls(
+  JCGO_STRREF_OF(jcgo_string2_CdngErAc))));
+ java_nio_charset_CodingErrorAction__REPLACE= (java_nio_charset_CodingErrorAction__new__Ls(
+  JCGO_STRREF_OF(jcgo_string3_CdngErAc)));
+ java_nio_charset_CodingErrorAction__REPORT= (java_nio_charset_CodingErrorAction__new__Ls(
+  JCGO_STRREF_OF(jcgo_string4_CdngErAc)));
+ JCGO_CLINIT_DONE(java_nio_charset_CodingErrorAction__class);
+}
+
+JCGO_NOSEP_DATA CONST struct java_nio_charset_CodingErrorAction_methods_s
+ java_nio_charset_CodingErrorAction_methods=
+{
+ JCGO_CLASSREF_OF(java_nio_charset_CodingErrorAction__class),
+ JCGO_GCJDESCR_ZEROINIT
+ OBJT_java_nio_charset_CodingErrorAction,
+ (JCGO_OBJSIZE_T)sizeof(struct java_nio_charset_CodingErrorAction_s),
+ NULL,
+ JCGO_CLINIT_INIT(java_nio_charset_CodingErrorAction__class__0)
+ 0,
+ java_lang_Object__equals__Lo,
+ java_lang_Object__hashCode__,
+ java_nio_charset_CodingErrorAction__toString__,
+ java_lang_Object__finalize__
+};
+
+JCGO_NOSEP_DATA struct java_nio_charset_CodingErrorAction_class_s
+ java_nio_charset_CodingErrorAction__class ATTRIBNONGC=
+{
+ {
+  &java_lang_Class_methods,
+  JCGO_MON_INIT
+  JCGO_OBJREF_OF(*(java_lang_Object)&java_nio_charset_CodingErrorAction_methods),
+  JCGO_STRREF_OF(jcgo_string1_CdngErAc),
+  JCGO_CLASSREF_OF(java_lang_Object__class),
+  ((jObjectArr)JCGO_OBJREF_OF(jcgo_array3_Object)),
+  0x1c1
+ }
+};
+
+JCGO_NOSEP_GCDATA java_nio_charset_CodingErrorAction java_nio_charset_CodingErrorAction__REPLACE
+ ATTRIBGCBSS= jnull;
+
+JCGO_NOSEP_GCDATA java_nio_charset_CodingErrorAction java_nio_charset_CodingErrorAction__REPORT
+ ATTRIBGCBSS= jnull;
+
+JCGO_NOSEP_DATA CONST jcgo_arrtype87_GmCnnctn jcgo_array5_CdngErAc=
+{
+ (jvtable)&jbyteArr_methods,
+ JCGO_MON_INIT
+ 34,
+ {
+  (jbyte)(jchar)106/*'j'*/, (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)118/*'v'*/,
+   (jbyte)(jchar)97/*'a'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)110/*'n'*/,
+   (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)46/*'.'*/,
+   (jbyte)(jchar)99/*'c'*/, (jbyte)(jchar)104/*'h'*/, (jbyte)(jchar)97/*'a'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)115/*'s'*/, (jbyte)(jchar)101/*'e'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)46/*'.'*/, (jbyte)(jchar)67/*'C'*/,
+   (jbyte)(jchar)111/*'o'*/, (jbyte)(jchar)100/*'d'*/, (jbyte)(jchar)105/*'i'*/,
+   (jbyte)(jchar)110/*'n'*/, (jbyte)(jchar)103/*'g'*/, (jbyte)(jchar)69/*'E'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)114/*'r'*/, (jbyte)(jchar)65/*'A'*/, (jbyte)(jchar)99/*'c'*/,
+   (jbyte)(jchar)116/*'t'*/, (jbyte)(jchar)105/*'i'*/, (jbyte)(jchar)111/*'o'*/,
+   (jbyte)(jchar)110/*'n'*/
+ }
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_CdngErAc
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array5_CdngErAc),
+ 0, 34, (jint)0xd2fade2cL
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_CdngErAc
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array761_Mdclnt),
+ 21, 6, (jint)0xb90bfdd2L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_CdngErAc
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array594_Mdclnt),
+ 2, 7, (jint)0x413cb2b4L
+};
+
+JCGO_NOSEP_DATA JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string4_CdngErAc
+ JCGO_THRD_ATTRNONGC=
+{
+ &java_lang_String_methods,
+ JCGO_MON_INIT
+ (java_lang_Object)JCGO_OBJREF_OF(jcgo_array736_Mdclnt),
+ 17, 6, (jint)0xc84c5534L
+};
+
+#ifdef CHKALL_java_nio_charset_CodingErrorAction
+#include "jcgochke.h"
+#endif
+
+#endif

jcgo_Out/CdngErAc.h

@@ -0,0 +1,67 @@
+/* DO NOT EDIT THIS FILE - it is machine generated (JCGO_116) */
+
+#ifdef JCGO_116
+
+JCGO_NOSEP_STATIC java_nio_charset_CodingErrorAction CFASTCALL
+java_nio_charset_CodingErrorAction__this__Ls( java_nio_charset_CodingErrorAction
+ This, java_lang_String name );
+JCGO_NOSEP_FRWINL java_nio_charset_CodingErrorAction CFASTCALL
+java_nio_charset_CodingErrorAction__new__Ls( java_lang_String name
+ );
+
+JCGO_NOSEP_INLINE java_lang_String CFASTCALL
+java_nio_charset_CodingErrorAction__toString__( java_nio_charset_CodingErrorAction
+ This );
+
+struct java_nio_charset_CodingErrorAction_methods_s
+{
+ java_lang_Class jcgo_class;
+ JCGO_GCJDESCR_DEFN
+ JCGO_TYPEID_T jcgo_typeid;
+ JCGO_OBJSIZE_T jcgo_objsize;
+ CONST struct jcgo_reflect_s *jcgo_reflect;
+ JCGO_CLINIT_DEFN
+ java_nio_charset_CodingErrorAction (CFASTCALL *jcgo_thisRtn)( java_nio_charset_CodingErrorAction
+  This );
+ jboolean (CFASTCALL *equals__Lo)( java_lang_Object This, java_lang_Object
+  obj );
+ jint (CFASTCALL *hashCode__)( java_lang_Object This );
+ java_lang_String (CFASTCALL *toString__)( java_nio_charset_CodingErrorAction
+  This );
+ void (CFASTCALL *finalize__)( java_lang_Object This );
+};
+
+struct java_nio_charset_CodingErrorAction_class_s
+{
+ struct java_lang_Class_s jcgo_class;
+};
+
+JCGO_SEP_EXTERN CONST struct java_nio_charset_CodingErrorAction_methods_s
+ java_nio_charset_CodingErrorAction_methods;
+JCGO_SEP_EXTERN struct java_nio_charset_CodingErrorAction_class_s java_nio_charset_CodingErrorAction__class;
+
+JCGO_NOSEP_STATIC void CFASTCALL
+java_nio_charset_CodingErrorAction__class__0( void );
+
+JCGO_SEP_GCEXTERN java_nio_charset_CodingErrorAction java_nio_charset_CodingErrorAction__REPLACE;
+JCGO_SEP_GCEXTERN java_nio_charset_CodingErrorAction java_nio_charset_CodingErrorAction__REPORT;
+
+struct java_nio_charset_CodingErrorAction_s
+{
+ CONST struct java_nio_charset_CodingErrorAction_methods_s *JCGO_IMMFLD_CONST
+  jcgo_methods;
+ JCGO_MON_DEFN
+ java_lang_String name;
+};
+
+JCGO_SEP_EXTERN CONST jcgo_arrtype87_GmCnnctn jcgo_array5_CdngErAc;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string1_CdngErAc;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string2_CdngErAc;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string3_CdngErAc;
+
+JCGO_SEP_EXTERN JCGO_NOTHR_CONST struct java_lang_String_s jcgo_string4_CdngErAc;
+
+#endif